File Coverage

blib/lib/Git/Hook/PostReceive.pm

Criterion	Covered	Total	%
statement	93	105	88.5
branch	42	52	80.7
condition	5	9	55.5
subroutine	14	15	93.3
pod	3	7	42.8
total	157	188	83.5

package Git::Hook::PostReceive;
$Git::Hook::PostReceive::VERSION = '0.3';
use warnings;
use strict;
use v5.14;
use feature "switch";

#ABSTRACT: Parses git commit information in post-receive hook scripts
use Cwd;
use File::Basename;
use Encode;

sub new {
    my ( $class, %args ) = @_;
    my $self = bless { utf8 => $args{utf8} ? 1 : 0, }, $class;
    $self;
}

sub read_stdin {
    my $self = shift;
    my @lines = @_ ? map { split "\n" } @_ : <>;
    my @branches;

    foreach my $line (@lines) {
        chomp $line;
        my $payload = $self->run( split /\s+/, $line );
        if (wantarray) {
            push @branches, $payload;
        }
        else {
            return $payload;
        }
    }
    return wantarray ? @branches : ();
}

sub _git_cmd {
    my $self = shift;
    my @args = qw(git);
    push @args, "--git-dir=" . $self->{git_dir}     if $self->{git_dir};
    push @args, "--work-tree=" . $self->{work_tree} if $self->{work_tree};
    return @args;
}

sub detect_action {
    my ( $self, $before, $after ) = @_;
    chomp $before;
    chomp $after;
    if ( $before ne '0000000000000000000000000000000000000000' ) {
        $before = qx(@{[ $self->_git_cmd() ]} rev-parse $before);
    }
    else {
        return { created => $before };
    }
    if ( $after ne '0000000000000000000000000000000000000000' ) {
        $after = qx(@{[ $self->_git_cmd() ]} rev-parse $after);
    }
    else {
        return { deleted => $after };
    }
    return { pushed => [ $before, $after ] };
}

sub get_repo {
    my $self = shift;
    return $self->{git_dir}   if $self->{git_dir};
    return $self->{work_tree} if $self->{work_tree};
    return getcwd();
}

sub run {
    my ( $self, $before, $after, $ref ) = @_;

    return unless $before and $after and $ref;

    my ( $created, $deleted ) = ( 0, 0 );
    if ( $before ne '0000000000000000000000000000000000000000' ) {
        $before = qx(@{[ $self->_git_cmd() ]} rev-parse $before);
        chomp $before;
    }
    else {
        $created = 1;
    }

    if ( $after ne '0000000000000000000000000000000000000000' ) {
        $after = qx(@{[ $self->_git_cmd() ]} rev-parse $after);
        chomp $after;
    }
    else {
        $deleted = 1;
    }

    return {
        before     => $before,
        after      => $after,
        repository => $self->get_repo(),
        ref        => $ref,
        created    => $created,
        deleted    => $deleted,
        commits    => [ $self->get_commits( $before, $after ) ]

            # head_commit => ... # ?
    };
}

sub get_commits {
    my ( $self, $before, $after ) = @_;

    my $log_string;

    if (   $before ne '0000000000000000000000000000000000000000'
        && $after ne '0000000000000000000000000000000000000000' )
    {
        $log_string = qx(@{[ $self->_git_cmd() ]} rev-list $before...$after);
    }
    elsif ( $after ne '0000000000000000000000000000000000000000' ) {
        $log_string = qx(@{[ $self->_git_cmd() ]} rev-list $after);
    }

    return () unless $log_string;

    return reverse map { $self->commit_info($_) } split /\n/, $log_string;
}

sub commit_info {
    my ( $self, $hash ) = @_;

    my $commit
        = qx{@{[ $self->_git_cmd() ]} show --format=fuller --date=iso --name-status $hash};
    $commit = decode( 'utf8', $commit ) if $self->{utf8};

    my @lines = split /\n/, $commit;

    my $info = {
        added    => [],
        removed  => [],
        modified => [] };

    for my $line (@lines) {
        $_ = $line;
        if (m{^commit (.*)$}i) {
            $info->{id} = $1;
        }
        elsif (m{^author:\s+(.*?)\s<(.*?)>}i) {
            $info->{author} = { name => $1, email => $2 };
        }
        elsif (m{^commit:\s+(.*?)\s<(.*?)>}i) {
            $info->{commiter} = { name => $1, email => $2 };
        }
        elsif (m{^authordate:\s+(.*)$}i) {
            $info->{timestamp} = $1;
            $info->{timestamp} =~ s/ /T/;
            $info->{timestamp} =~ s/ ([+-])(\d\d)(\d\d)/$1$2:$3/;
        }
        elsif (m{^merge: (\w+)\s+(\w+)}i) {
            $info->{merge} = { parent1 => $1, parent2 => $2 };
        }
        elsif (m{^A\t(.+)}) {
            push @{ $info->{added} }, $1;
        }
        elsif (m{^D\t(.+)}) {
            push @{ $info->{removed} }, $1;
        }
        elsif (m{^M\t(.+)}) {
            push @{ $info->{modified} }, $1;
        }
        elsif (m{^    (.*)}) {
            $info->{message} .= $1 . "\n";
        }
    }
    chomp $info->{message};
    return $info;
}

1;

__END__