lib/Gitalist/Git/Object/Commit.pm

   1 package Gitalist::Git::Object::Commit;
   2 use MooseX::Declare;
   3
   4 class Gitalist::Git::Object::Commit
   5     extends Gitalist::Git::Object
   6     with Gitalist::Git::Object::HasTree {
   7         use MooseX::Types::Moose qw/Str Int Bool Maybe ArrayRef/;
   8         use MooseX::Types::Common::String qw/NonEmptySimpleStr SimpleStr/;
   9         use Moose::Autobox;
  10         use List::MoreUtils qw/any zip/;
  11         our $SHA1RE = qr/[0-9a-fA-F]{40}/;
  12
  13         has '+type' => ( default => 'commit' );
  14         has '+_gpp_obj' => ( handles => [ 'comment',
  15                                           'tree_sha1',
  16                                           'committer',
  17                                           'committed_time',
  18                                           'author',
  19                                           'authored_time',
  20                                           'parents',
  21                                           'parent_sha1',
  22                                           'parent_sha1s',
  23                                       ],
  24                          );
  25
  26         method sha_by_path ($path) {
  27             $path =~ s{/+$}();
  28             # FIXME should this really just take the first result?
  29             my @paths = $self->repository->run_cmd('ls-tree', $self->sha1, '--', $path)
  30                 or return;
  31             my $line = $paths[0];
  32
  33             #'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa      panic.c'
  34             $line =~ m/^([0-9]+) (.+) ($SHA1RE)\t/;
  35             my $sha1 = $3;
  36             return $sha1;
  37     }
  38
  39         method get_patch ( Maybe[NonEmptySimpleStr] $parent_hash?,
  40                            Int $patch_count?) {
  41             # assembling the git command to execute...
  42             my @cmd = qw/format-patch --encoding=utf8 --stdout/;
  43
  44             # patch, or patch set?
  45             push @cmd,
  46                 defined $patch_count
  47                 ? "-$patch_count -n" : "-1";
  48
  49             # refspec
  50             if (defined $parent_hash) {
  51                 #  if a parent is specified: hp..h
  52                 push @cmd, "$parent_hash.." . $self->sha1;
  53             } else {
  54                 #  if not, but a merge commit: --cc h
  55                 #  otherwise: --root h
  56                 push @cmd, $self->parents->length > 1
  57                     ? '--cc' : '--root';
  58                 push @cmd, $self->sha1;
  59             }
  60             return $self->_run_cmd_fh( @cmd );
  61         }
  62
  63         method diff ( Bool              :$patch?,
  64                       NonEmptySimpleStr :$parent?,
  65                       NonEmptySimpleStr :$filename?
  66                     ) {
  67             $parent = $parent
  68                 ? $parent
  69                     : $self->parents <= 1
  70                         ? $self->parent_sha1
  71                             : '-c';
  72             my @etc = (
  73                 ( $filename  ? ('--', $filename) : () ),
  74             );
  75
  76             # If we're not comparing against something and we have multiple
  77             # parents then it's a merge commit so show what was merged.
  78             my $sha1 = $parent && $parent eq '-c' && @{[$self->parents]} > 1
  79                  ? sprintf("%s^1..%s^2", ($self->sha1) x 2)
  80                       : $self->sha1;
  81
  82             my @out = $self->_raw_diff(
  83                 ( $patch ? '--patch-with-raw' : () ),
  84                 ( $parent ? $parent : () ),
  85                 $sha1, @etc,
  86             );
  87
  88             # XXX Yes, there is much wrongness having _parse_diff_tree be destructive.
  89             my @difftree = $self->_parse_diff_tree(\@out);
  90
  91             return \@difftree
  92                 unless $patch;
  93
  94             # The blank line between the tree and the patch.
  95             shift @out;
  96
  97             # XXX And no I'm not happy about having diff return tree + patch.
  98             return \@difftree, [$self->_parse_diff(@out)];
  99         }
 100
 101         ## Private methods
 102         # gitweb uses the following sort of command for diffing merges:
 103         # /home/dbrook/apps/bin/git --git-dir=/home/dbrook/dev/app/.git diff-tree -r -M --no-commit-id --patch-with-raw --full-index --cc 316cf158df3f6207afbae7270bcc5ba0 --
 104         # and for regular diffs
 105         # /home/dbrook/apps/bin/git --git-dir=/home/dbrook/dev/app/.git diff-tree -r -M --no-commit-id --patch-with-raw --full-index 2e3454ca0749641b42f063730b0090e1 316cf158df3f6207afbae7270bcc5ba0 --
 106         method _raw_diff (@args) {
 107             return $self->_run_cmd_list(
 108                 qw(diff-tree -r -M --no-commit-id --full-index),
 109                 @args
 110             );
 111         }
 112
 113         method _parse_diff_tree ($diff) {
 114             my @keys = qw(modesrc modedst sha1src sha1dst status src dst);
 115             my @ret;
 116             while (@$diff and $diff->[0] =~ /^:\d+/) {
 117                 my $line = shift @$diff;
 118                 # see. man git-diff-tree for more info
 119                 # mode src, mode dst, sha1 src, sha1 dst, status, src[, dst]
 120                 my @vals = $line =~ /^:(\d+) (\d+) ($SHA1RE) ($SHA1RE) ([ACDMRTUX]\d*)\t([^\t]+)(?:\t([^\n]+))?$/;
 121                 my %line = zip @keys, @vals;
 122                 # Some convenience keys
 123                 $line{file}   = $line{src};
 124                 $line{sha1}   = $line{sha1dst};
 125                 $line{is_new} = $line{sha1src} =~ /^0+$/
 126                     if $line{sha1src};
 127                 @line{qw/status sim/} = $line{status} =~ /(R)0*(\d+)/
 128                     if $line{status} =~ /^R/;
 129                 push @ret, \%line;
 130             }
 131
 132             return @ret;
 133         }
 134
 135         method _parse_diff (@diff) {
 136             my @ret;
 137             for (@diff) {
 138                 # This regex is a little pathological.
 139                 if (m{^diff --git (a/(.*?)) (b/\2)}) {
 140                     push @ret, {
 141                         head => $_,
 142                         a    => $1,
 143                         b    => $3,
 144                         file => $2,
 145                         diff => '',
 146                     };
 147                     next;
 148                 }
 149
 150                 if (/^index (\w+)\.\.(\w+)(?: (\d+))?$/) {
 151                     @{$ret[-1]}{qw(index src dst mode)} = ($_, $1, $2, $3);
 152                     next
 153                 }
 154
 155                 # XXX Somewhat hacky. Ahem.
 156                 $ret[@ret ? -1 : 0]{diff} .= "$_\n";
 157             }
 158
 159             return @ret;
 160         }
 161
 162
 163   # XXX A prime candidate for caching.
 164   method blame ( NonEmptySimpleStr $filename, SimpleStr $sha1 ) {
 165     my @blameout = $self->_run_cmd_list(
 166       blame => '-p', $sha1 ? $sha1 : $self->sha1, '--', $filename
 167     );
 168
 169     my(%commitdata, @filedata);
 170     while(defined(local $_ = shift @blameout)) {
 171       my ($sha1, $orig_lineno, $lineno, $group_size) =
 172         /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/;
 173
 174       $commitdata{$sha1} = {}
 175         unless exists $commitdata{$sha1};
 176
 177       my $commit = $commitdata{$sha1};
 178       my $line;
 179       until(($line = shift @blameout) =~ s/^\t//) {
 180         $commit->{$1} = $2
 181          if $line =~ /^(\S+) (.*)/;
 182       }
 183
 184       unless(exists $commit->{author_dt}) {
 185         for my $t (qw/author committer/) {
 186           my $dt = DateTime->from_epoch(epoch => $commit->{"$t-time"});
 187           $dt->set_time_zone($commit->{"$t-tz"});
 188           $commit->{"$t\_dt"} = $dt;
 189         }
 190       }
 191
 192       push @filedata, {
 193         line => $line,
 194         commit => { sha1 => $sha1, %$commit },
 195         meta => {
 196           orig_lineno => $orig_lineno,
 197           lineno => $lineno,
 198           ( $group_size ? (group_size => $group_size) : () ),
 199         },
 200       };
 201     }
 202
 203     return \@filedata;
 204   }
 205 }
 206
 207
 208 1;
 209
 210 __END__
 211
 212 =head1 NAME
 213
 214 Gitalist::Git::Object::Commit
 215
 216 =head1 SYNOPSIS
 217
 218     my $commit = Repository->get_object($commit_sha1);
 219
 220 =head1 DESCRIPTION
 221
 222 Represents a commit object in a git repository.
 223 Subclass of C<Gitalist::Git::Object>.
 224
 225
 226 =head1 ATTRIBUTES
 227
 228 =head2 committer
 229
 230 =head2 committed_time
 231
 232 =head2 author
 233
 234 =head2 authored_time
 235
 236 =head2 comment
 237
 238 =head2 tree_sha1
 239
 240 =head2 parents
 241
 242 =head2 parent_sha1
 243
 244 =head2 parent_sha1s
 245
 246
 247 =head1 METHODS
 248
 249 =head2 sha_by_path ($path)
 250
 251 Returns the tree/file sha1 for a given path in a commit.
 252
 253 =head2 get_patch
 254
 255 =head2 diff
 256
 257 =head2 blame
 258
 259 =head1 AUTHORS
 260
 261 See L<Gitalist> for authors.
 262
 263 =head1 LICENSE
 264
 265 See L<Gitalist> for the license.
 266
 267 =cut