Migrated commit action to new model.

::Object now delegates to Git::PurePerl where appropriate.

diff --git a/lib/Gitalist/Controller/Root.pm b/lib/Gitalist/Controller/Root.pm
index 9189f85..57eef4f 100644 (file)
--- a/lib/Gitalist/Controller/Root.pm
+++ b/lib/Gitalist/Controller/Root.pm
@@ -220,12 +220,13 @@ Exposes a given commit.
 
 sub commit : Local {
   my ( $self, $c ) = @_;
-
+  $c->stash(current_model => 'GitRepos');
+  my $project = $c->stash->{Project};
   my $commit = $self->_get_commit($c);
   $c->stash(
       commit      => $commit,
-      diff_tree   => ($c->model()->diff(commit => $commit))[0],
-      refs      => $c->model()->references,
+      diff_tree   => ($project->diff(commit => $commit))[0],
+      refs      => $project->references,
       action      => 'commit',
   );
 }

diff --git a/lib/Gitalist/Git/Object.pm b/lib/Gitalist/Git/Object.pm
index 00f037e..b47ab93 100644 (file)
--- a/lib/Gitalist/Git/Object.pm
+++ b/lib/Gitalist/Git/Object.pm
@@ -10,7 +10,10 @@ class Gitalist::Git::Object {
                      required => 1,
                      is => 'ro',
                      weak_ref => 1,
-                     handles => [ 'run_cmd' ],
+                     handles => {
+                         _run_cmd => 'run_cmd',
+                         _get_gpp_object => 'get_gpp_object',
+                     },
                  );
     has sha1 => ( isa => NonEmptySimpleStr,
                required => 1,
@@ -22,6 +25,21 @@ class Gitalist::Git::Object {
                   lazy_build => 1 )
         for qw/type modestr size/;
 
+    has _gpp_obj => ( isa => 'Git::PurePerl::Object',
+                      required => 1,
+                      is => 'ro',
+                      lazy_build => 1,
+                      handles => [ 'parents',
+                                   'parent_sha1',
+                                   'comment',
+                                   'author',
+                                   'authored_time',
+                                   'committer',
+                                   'committed_time',
+                                   'tree_sha1',
+                               ],
+                  );
+
     # objects can't determine their mode or filename
     has file => ( isa => NonEmptySimpleStr,
                   required => 0,
@@ -31,7 +49,11 @@ class Gitalist::Git::Object {
                 default => 0,
                 is => 'ro' );
 
-    method BUILD { $self->$_() for qw/type size modestr/ }
+    method BUILD { $self->$_() for qw/_gpp_obj type size modestr/ }
+
+    method _build__gpp_obj {
+        return $self->_get_gpp_object($self->sha1)
+    }
 
     foreach my $key (qw/ type size /) {
         method "_build_$key" {
@@ -47,7 +69,7 @@ class Gitalist::Git::Object {
     }
 
     method _cat_file_with_flag ($flag) {
-        $self->run_cmd('cat-file', '-' . $flag, $self->{sha1})
+        $self->_run_cmd('cat-file', '-' . $flag, $self->{sha1})
     }
 
 =head2 contents

diff --git a/lib/Gitalist/Git/Project.pm b/lib/Gitalist/Git/Project.pm
index 9ce7e5a..844dcf3 100644 (file)
--- a/lib/Gitalist/Git/Project.pm
+++ b/lib/Gitalist/Git/Project.pm
@@ -6,6 +6,7 @@ class Gitalist::Git::Project {
     use MooseX::Types::Moose qw/Str Maybe Bool HashRef/;
     use DateTime;
     use MooseX::Types::Path::Class qw/Dir/;
+    use List::MoreUtils qw/any zip/;
     use Gitalist::Git::Util;
     use aliased 'Gitalist::Git::Object';
 
@@ -194,9 +195,8 @@ The keys for each item will be:
         return @ret;
     }
 
-    use Gitalist::Git::Object;
     method get_object (Str $sha1) {
-        return Gitalist::Git::Object->new(
+        return Object->new(
             project => $self,
             sha1 => $sha1,
         );
@@ -286,6 +286,101 @@ The keys for each item will be:
                     map  split(/\n/, $_, 6), split /\0/, $output;
     }
 
+    # XXX Ideally this would return a wee object instead of ad hoc structures.
+    method diff ( Gitalist::Git::Object :$commit,
+                  Bool :$patch?,
+                  NonEmptySimpleStr :$parent?,
+                  NonEmptySimpleStr :$file? ) {
+        # Use parent if specifed, else take the parent from the commit
+        # if there is only one, otherwise it was a merge commit.
+        $parent = $parent
+            ? $parent
+            : $commit->parents <= 1
+            ? $commit->parent_sha1
+            : '-c';
+        my @etc = (
+            ( $file  ? ('--', $file) : () ),
+        );
+
+        my @out = $self->raw_diff(
+            ( $patch ? '--patch-with-raw' : () ),
+            $parent, $commit->sha1, @etc
+        );
+
+        # XXX Yes, there is much wrongness having parse_diff_tree be destructive.
+        my @difftree = $self->parse_diff_tree(\@out);
+
+        return \@difftree
+            unless $patch;
+
+        # The blank line between the tree and the patch.
+        shift @out;
+
+        # XXX And no I'm not happy about having diff return tree + patch.
+        return \@difftree, [$self->parse_diff(@out)];
+    }
+
+    method parse_diff (@diff) {
+        my @ret;
+        for (@diff) {
+            # This regex is a little pathological.
+            if(m{^diff --git (a/(.*?)) (b/\2)}) {
+                push @ret, {
+                    head => $_,
+                    a    => $1,
+                    b    => $3,
+                    file => $2,
+                    diff => '',
+                };
+                next;
+            }
+
+            if(/^index (\w+)\.\.(\w+) (\d+)$/) {
+                @{$ret[-1]}{qw(index src dst mode)} = ($_, $1, $2, $3);
+                next
+            }
+
+            # XXX Somewhat hacky. Ahem.
+            $ret[@ret ? -1 : 0]{diff} .= "$_\n";
+        }
+
+        return @ret;
+    }
+
+    # gitweb uses the following sort of command for diffing merges:
+# /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 --
+# and for regular diffs
+# /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 --
+
+    method raw_diff (@args) {
+        my $cmdout = $self->run_cmd(
+            qw(diff-tree -r -M --no-commit-id --full-index),
+            @args
+        );
+        return $cmdout ? split(/\n/, $cmdout) : ();
+    }
+
+    method parse_diff_tree ($diff) {
+        my @keys = qw(modesrc modedst sha1src sha1dst status src dst);
+        my @ret;
+        while (@$diff and $diff->[0] =~ /^:\d+/) {
+            my $line = shift @$diff;
+            # see. man git-diff-tree for more info
+            # mode src, mode dst, sha1 src, sha1 dst, status, src[, dst]
+            my @vals = $line =~ /^:(\d+) (\d+) ($SHA1RE) ($SHA1RE) ([ACDMRTUX]\d*)\t([^\t]+)(?:\t([^\n]+))?$/;
+            my %line = zip @keys, @vals;
+            # Some convenience keys
+            $line{file}   = $line{src};
+            $line{sha1}   = $line{sha1dst};
+            $line{is_new} = $line{sha1src} =~ /^0+$/
+               if $line{sha1src};
+            @line{qw/status sim/} = $line{status} =~ /(R)(\d+)/
+                if $line{status} =~ /^R/;
+            push @ret, \%line;
+        }
+
+        return @ret;
+    }
 
     # Compatibility
 

diff --git a/root/commit.tt2 b/root/commit.tt2
index c13cb61..8e114d0 100644 (file)
--- a/root/commit.tt2
+++ b/root/commit.tt2
@@ -22,10 +22,10 @@
   </dd>
  [% FOREACH parent IN commit.parents %]
  <dt>parent</dt>
-  <dd>[% parent %]
+  <dd>[% parent.sha1  %]
     <span class='action-list'>
-        <a href="[% c.uri_for("commit", {h=parent}) %]">commit</a>
-        <a href="[% c.uri_for("commitdiff", {hp=parent, h=commit.sha1}) %]">diff</a>
+        <a href="[% c.uri_for("commit", {h=parent.sha1}) %]">commit</a>
+        <a href="[% c.uri_for("commitdiff", {hp=parent.sha1, h=commit.sha1}) %]">diff</a>
        </span>
    </dd>
  [% END %]