Git::Wrapper - wrap git(7) command-line interface

  my $git = Git::Wrapper->new('/var/foo');

  $git->commit(...)
  print $_->message for $git->log;

  $git->commit({ all => 1, message => "stuff" });

  $git->checkout("mybranch");

  @sha1s_and_titles = $git->rev_list({ all => 1, pretty => 'oneline' });

  my $git = Git::Wrapper->new($dir);

  print $git->dir; # /var/foo

  my $version = $git->version; # 1.6.1.4.8.15.16.23.42

  my @logs = $git->log;

  my $statuses = $git->status;

  my $dirty_flag = $statuses->is_dirty;

  my @status = $statuses->get($group)

  my $from = $status->from;

  my $to = $status->to;

  my $mode = $status->mode;

    my $git = Git::Wrapper->new('/path/to/git/repo');
    my $statuses = $git->status;
    for my $type (qw<indexed changed unknown conflict>) {
        my @states = $statuses->get($type)
            or next;
        print "Files in state $type\n";
        for (@states) {
            print '  ', $_->mode, ' ', $_->from;
            print ' renamed to ', $_->to
                if $_->mode eq 'renamed';
            print "\n";
        }
    }

use 5.006;
use strict;
use warnings;

package Git::Wrapper;
BEGIN {
  $Git::Wrapper::VERSION = '0.014';
}
#ABSTRACT: wrap git(7) command-line interface

our $DEBUG=0;
use IPC::Open3 () ;
use Symbol;
use File::pushd;

sub new {
  my ($class, $arg, %opt) = @_;
  my $self = bless { dir => $arg, %opt } => $class;
  die "usage: $class->new(\$dir)" unless $self->dir;
  return $self;
}

sub dir { shift->{dir} }

my $GIT = 'git';

sub _opt {
  my $name = shift;
  $name =~ tr/_/-/;
  return length($name) == 1
    ? "-$name"
    : "--$name"
  ;
}

sub _cmd {
  my $self = shift;

  my $cmd = shift;

  my $opt = ref $_[0] eq 'HASH' ? shift : {};

  my @cmd = $GIT;

  for (grep { /^-/ } keys %$opt) {
    (my $name = $_) =~ s/^-//;
    my $val = delete $opt->{$_};
    next if $val eq '0';
    push @cmd, _opt($name) . ($val eq '1' ? "" : "=$val");
  }
  push @cmd, $cmd;
  for my $name (keys %$opt) {
    my $val = delete $opt->{$name};
    next if $val eq '0';
    push @cmd, _opt($name) . ($val eq '1' ? "" : "=$val");
  }
  push @cmd, @_;

  #print "running [@cmd]\n";
  my @out;
  my @err;

  {
    my $d = pushd $self->dir;
    my ($wtr, $rdr, $err);
    $err = Symbol::gensym;
    print STDERR join(' ',@cmd),"\n" if $DEBUG;
    my $pid = IPC::Open3::open3($wtr, $rdr, $err, @cmd);
    close $wtr;
    chomp(@out = <$rdr>);
    chomp(@err = <$err>);
    waitpid $pid, 0;
  };
  #print "status: $?\n";
  if ($?) {
    die Git::Wrapper::Exception->new(
      output => \@out,
      error  => \@err,
      status => $? >> 8,
    );
  }

  chomp(@out);
  return @out;
}

sub AUTOLOAD {
  my $self = shift;
  (my $meth = our $AUTOLOAD) =~ s/.+:://;
  return if $meth eq 'DESTROY';
  $meth =~ tr/_/-/;

  return $self->_cmd($meth, @_);
}

sub version {
  my $self = shift;
  my ($version) = $self->_cmd('version');
  $version =~ s/^git version //;
  return $version;
}

sub log {
  my $self = shift;
  my $opt  = ref $_[0] eq 'HASH' ? shift : {};
  $opt->{no_color} = 1;
  $opt->{pretty}   = 'medium';
  my @out = $self->_cmd(log => $opt, @_);

  my @logs;
  while (my $line = shift @out) {
    die "unhandled: $line" unless $line =~ /^commit (\S+)/;
    my $current = Git::Wrapper::Log->new($1);
    $line = shift @out; # next line;
    while ($line =~ /^(\S+):\s+(.+)$/) {
      $current->attr->{lc $1} = $2;
      $line = shift @out; # next line;
    }
    die "no blank line separating head from message" if $line;
    my $message = '';
    while (
      @out 
      and $out[0] !~ /^commit (\S+)/ 
      and length($line = shift @out)
    ) {
      $line =~ s/^\s+//;
      $message .= "$line\n";
    }
    $current->message($message);
    push @logs, $current;
  }

  return @logs;
}

my %STATUS_CONFLICTS = map { $_ => 1 } qw<DD AU UD UA DU AA UU>;

sub status {
  my $self = shift;
  my $opt  = ref $_[0] eq 'HASH' ? shift : {};
  $opt->{$_} = 1 for qw<porcelain>;
  my @out = $self->_cmd(status => $opt, @_);
  my $statuses = Git::Wrapper::Statuses->new;
  return $statuses if !@out;

  for (@out) {
    my ($x, $y, $from, $to) = $_ =~ /\A(.)(.) (.*?)(?: -> (.*))?\z/;

    if ($STATUS_CONFLICTS{"$x$y"}) {
      $statuses->add('conflict', "$x$y", $from, $to);
    }
    elsif ($x eq '?' && $y eq '?') {
      $statuses->add('unknown', '?', $from, $to);
    }
    else {
      $statuses->add('changed', $y, $from, $to)
        if $y ne ' ';
      $statuses->add('indexed', $x, $from, $to)
        if $x ne ' ';
    }
  }
  return $statuses;
}

package Git::Wrapper::Exception;
BEGIN {
  $Git::Wrapper::Exception::VERSION = '0.014';
}

sub new { my $class = shift; bless { @_ } => $class }

use overload (
  q("") => 'error',
  fallback => 1,
);

sub output { join "", map { "$_\n" } @{ shift->{output} } }
sub error  { join "", map { "$_\n" } @{ shift->{error} } }
sub status { shift->{status} }

package Git::Wrapper::Log;
BEGIN {
  $Git::Wrapper::Log::VERSION = '0.014';
}

sub new {
  my ($class, $id, %arg) = @_;
  return bless {
    id => $id,
    attr => {},
    %arg,
  } => $class;
}

sub id { shift->{id} }

sub attr { shift->{attr} }

sub message { @_ > 1 ? ($_[0]->{message} = $_[1]) : $_[0]->{message} }

sub date { shift->attr->{date} }

sub author { shift->attr->{author} }

1;

package Git::Wrapper::Statuses;
BEGIN {
  $Git::Wrapper::Statuses::VERSION = '0.014';
}

sub new { return bless {} => shift }

sub add {
  my ($self, $type, $mode, $from, $to) = @_;
  my $status = Git::Wrapper::Status->new($mode, $from, $to);
  push @{ $self->{ $type } }, $status;
}

sub get {
  my ($self, $type) = @_;
  return @{ defined $self->{$type} ? $self->{$type} : [] };
}

sub is_dirty {
  my( $self ) = @_;

  return keys %$self ? 1 : 0;
}

1;

package Git::Wrapper::Status;
BEGIN {
  $Git::Wrapper::Status::VERSION = '0.014';
}

my %modes = (
  M   => 'modified',
  A   => 'added',
  D   => 'deleted',
  R   => 'renamed',
  C   => 'copied',
  U   => 'conflict',
  '?' => 'unknown',
  DD  => 'both deleted',
  AA  => 'both added',
  UU  => 'both modified',
  AU  => 'added by us',
  DU  => 'deleted by us',
  UA  => 'added by them',
  UD  => 'deleted by them',
);

sub new {
  my ($class, $mode, $from, $to) = @_;
  return bless {
    mode => $mode,
    from => $from,
    to   => $to,
  } => $class;
}

sub mode { $modes{ shift->{mode} } }

sub from { shift->{from} }

sub to   { defined( $_[0]->{to} ) ? $_[0]->{to} : '' }

__END__