[catagits/Gitalist.git] / lib / Gitalist / Controller / Root.pm

package Gitalist::Controller::Root;
use Moose;
use namespace::autoclean;

BEGIN { extends 'Catalyst::Controller' }

__PACKAGE__->config->{namespace} = '';

use IO::Capture::Stdout;
use Sys::Hostname ();
use XML::Atom::Feed;
use XML::Atom::Entry;
use XML::RSS;

=head1 NAME

Gitalist::Controller::Root - Root Controller for Gitalist

=head1 DESCRIPTION

[enter your description here]

=head1 METHODS

=cut

=head2 index

=cut

=head2 run_gitweb

The C<gitweb> shim. It should now only be explicitly accessible by
modifying the URL.

=cut

sub run_gitweb {
  my ( $self, $c ) = @_;

  # XXX A slippery slope to be sure.
  if($c->req->param('a')) {
    my $capture = IO::Capture::Stdout->new();
    $capture->start();
    eval {
      my $action = gitweb::main($c);
      $action->();
    };
    $capture->stop();

    use Data::Dumper;
    die Dumper($@)
      if $@;

    my $output = join '', $capture->read;
    $c->stash->{gitweb_output} = $output;
    $c->stash->{template} = 'gitweb.tt2';
  }
}

sub _get_object {
  my($self, $c, $haveh) = @_;

  my $h = $haveh || $c->req->param('h') || '';
  my $f = $c->req->param('f');

  my $m = $c->stash->{Project};
  my $pd = $m->path;

  # Either use the provided h(ash) parameter, the f(ile) parameter or just use HEAD.
  my $hash = ($h =~ /[^a-f0-9]/ ? $m->head_hash($h) : $h)
          || ($f && $m->hash_by_path($f))
          || $m->head_hash
          # XXX This could definitely use more context.
          || Carp::croak("Couldn't find a hash for the commit object!");

  my $commit = $m->get_object($hash)
    or Carp::croak("Couldn't find a commit object for '$hash' in '$pd'!");

  return $commit;
}

=head2 index

Provides the project listing.

=cut

sub index :Path :Args(0) {
  my ( $self, $c ) = @_;

  $c->detach($c->req->param('a'))
    if $c->req->param('a');

  my @list = @{ $c->model()->projects };
  die 'No projects found in '. $c->model->repo_dir
    unless @list;

  my $search = $c->req->param('s') || '';
  if($search) {
    @list = grep {
         index($_->name, $search) > -1
      or ( $_->description !~ /^Unnamed repository/ and index($_->description, $search) > -1 )
    } @list
  }

  $c->stash(
    search_text => $search,
    projects    => \@list,
    action      => 'index',
  );
}

=head2 summary

A summary of what's happening in the repo.

=cut

sub summary : Local {
  my ( $self, $c ) = @_;
  my $project = $c->stash->{Project};
  $c->detach('error_404') unless $project;
  my $commit = $self->_get_object($c);
  my @heads  = @{$project->heads};
  my $maxitems = Gitalist->config->{paging}{summary} || 10;
  $c->stash(
    commit    => $commit,
    log_lines => [$project->list_revs(
        sha1 => $commit->sha1,
        count => $maxitems,
    )],
    refs      => $project->references,
    heads     => [ @heads[0 .. ($#heads < $maxitems ? $#heads : $maxitems)] ],
    action    => 'summary',
  );
}

=head2 heads

The current list of heads (aka branches) in the repo.

=cut

sub heads : Local {
  my ( $self, $c ) = @_;
  my $project = $c->stash->{Project};
  $c->stash(
    commit => $self->_get_object($c),
    heads  => $project->heads,
    action => 'heads',
  );
}

=head2 blob

The blob action i.e the contents of a file.

=cut

sub blob : Local {
  my ( $self, $c ) = @_;
  my $project = $c->stash->{Project};
  my $h  = $c->req->param('h')
       || $project->hash_by_path($c->req->param('hb'), $c->req->param('f'))
       || die "No file or sha1 provided.";
  my $hb = $c->req->param('hb')
       || $project->head_hash
       || die "Couldn't discern the corresponding head.";

  my $filename = $c->req->param('f') || '';

  $c->stash(
    blob     => $project->get_object($h)->content,
    head     => $project->get_object($hb),
    filename => $filename,
    # XXX Hack hack hack, see View::SyntaxHighlight
    language => ($filename =~ /\.p[lm]$/ ? 'Perl' : ''),
    action   => 'blob',
  );

  $c->forward('View::SyntaxHighlight')
    unless $c->stash->{no_wrapper};
}

sub blob_plain : Local {
  my($self, $c) = @_;

  $c->stash(no_wrapper => 1);
  $c->response->content_type('text/plain; charset=utf-8');

  $c->forward('blob');
}

sub blobdiff_plain : Local {
  my($self, $c) = @_;

  $c->stash(no_wrapper => 1);
  $c->response->content_type('text/plain; charset=utf-8');

  $c->forward('blobdiff');

}

=head2 blobdiff

Exposes a given diff of a blob.

=cut

sub blobdiff : Local {
  my ( $self, $c ) = @_;
  my $commit = $self->_get_object($c, $c->req->param('hb'));
  my $filename = $c->req->param('f')
              || croak("No file specified!");
  my($tree, $patch) = $c->stash->{Project}->diff(
    commit => $commit,
    patch  => 1,
    parent => $c->req->param('hpb') || undef,
    file   => $filename,
  );
  $c->stash(
    commit    => $commit,
    diff      => $patch,
    # XXX Hack hack hack, see View::SyntaxHighlight
    blobs     => [$patch->[0]->{diff}],
    language  => 'Diff',
    action    => 'blobdiff',
  );

  $c->forward('View::SyntaxHighlight')
    unless $c->stash->{no_wrapper};
}

=head2 commit

Exposes a given commit.

=cut

sub commit : Local {
  my ( $self, $c ) = @_;
  my $project = $c->stash->{Project};
  my $commit = $self->_get_object($c);
  $c->stash(
      commit      => $commit,
      diff_tree   => ($project->diff(commit => $commit))[0],
      refs      => $project->references,
      action      => 'commit',
  );
}

=head2 commitdiff

Exposes a given diff of a commit.

=cut

sub commitdiff : Local {
  my ( $self, $c ) = @_;
  my $commit = $self->_get_object($c);
  my($tree, $patch) = $c->stash->{Project}->diff(
      commit => $commit,
      parent => $c->req->param('hp') || undef,
      patch  => 1,
  );
  $c->stash(
    commit    => $commit,
    diff_tree => $tree,
    diff      => $patch,
    # XXX Hack hack hack, see View::SyntaxHighlight
    blobs     => [map $_->{diff}, @$patch],
    language  => 'Diff',
    action    => 'commitdiff',
  );

  $c->forward('View::SyntaxHighlight')
    unless $c->stash->{no_wrapper};
}

sub commitdiff_plain : Local {
  my($self, $c) = @_;

  $c->stash(no_wrapper => 1);
  $c->response->content_type('text/plain; charset=utf-8');

  $c->forward('commitdiff');
}

=head2 shortlog

Expose an abbreviated log of a given sha1.

=cut

sub shortlog : Local {
  my ( $self, $c ) = @_;
  my $project = $c->stash->{Project};
  my $commit  = $self->_get_object($c);
  my %logargs = (
      sha1   => $commit->sha1,
      count  => Gitalist->config->{paging}{log} || 25,
      ($c->req->param('f') ? (file => $c->req->param('f')) : ())
  );

  my $page = $c->req->param('pg') || 0;
  $logargs{skip} = $c->req->param('pg') * $logargs{count}
    if $c->req->param('pg');

  $c->stash(
      commit    => $commit,
      log_lines => [$project->list_revs(%logargs)],
      refs      => $project->references,
      action    => 'shortlog',
      page      => $page,
  );
}

=head2 log

Calls shortlog internally. Perhaps that should be reversed ...

=cut
sub log : Local {
    $_[0]->shortlog($_[1]);
    $_[1]->stash->{action} = 'log';
}

# For legacy support.
sub history : Local {
  $_[0]->shortlog(@_[1 .. $#_]);
}

=head2 tree

The tree of a given commit.

=cut

sub tree : Local {
  my ( $self, $c ) = @_;
  my $project = $c->stash->{Project};
  my $commit  = $self->_get_object($c, $c->req->param('hb'));
  my $tree    = $self->_get_object($c, $c->req->param('h') || $commit->tree_sha1);
  $c->stash(
      commit    => $commit,
      tree      => $tree,
      tree_list => [$project->list_tree($tree->sha1)],
      path      => $c->req->param('f') || '',
      action    => 'tree',
  );
}

=head2 reflog

Expose the local reflog. This may go away.

=cut

sub reflog : Local {
  my ( $self, $c ) = @_;
  my @log = $c->stash->{Project}->reflog(
      '--since=yesterday'
  );

  $c->stash(
      log    => \@log,
      action => 'reflog',
  );
}

sub search : Local {
  my($self, $c) = @_;
  $c->stash(current_action => 'GitRepos');
  my $project = $c->stash->{Project};
  my $commit  = $self->_get_object($c);
  # Lifted from /shortlog.
  my %logargs = (
    sha1   => $commit->sha1,
    count  => Gitalist->config->{paging}{log},
    ($c->req->param('f') ? (file => $c->req->param('f')) : ()),
    search => {
      type   => $c->req->param('type'),
      text   => $c->req->param('text'),
      regexp => $c->req->param('regexp') || 0,
    },
  );

  $c->stash(
      commit  => $commit,
      results => [$project->list_revs(%logargs)],
      action  => 'search',
	  # This could be added - page      => $page,
  );
}

sub search_help : Local {
    my ($self, $c) = @_;
    $c->stash(template => 'search_help.tt2');
}

sub atom : Local {
  my($self, $c) = @_;

  my $feed = XML::Atom::Feed->new;

  my $host = lc Sys::Hostname::hostname();
  $feed->title($host . ' - ' . Gitalist->config->{name});
  $feed->updated(~~DateTime->now);

  my $project = $c->stash->{Project};
  my %logargs = (
      sha1   => $project->head_hash,
      count  => Gitalist->config->{paging}{log} || 25,
      ($c->req->param('f') ? (file => $c->req->param('f')) : ())
  );

  my $mk_title = $c->stash->{short_cmt};
  for my $commit ($project->list_revs(%logargs)) {
    my $entry = XML::Atom::Entry->new;
    $entry->title( $mk_title->($commit->comment) );
    $entry->id($c->uri_for('commit', {h=>$commit->sha1}));
    # XXX Needs work ...
    $entry->content($commit->comment);
    $feed->add_entry($entry);
  }

  $c->response->body($feed->as_xml);
  $c->response->content_type('application/atom+xml');
  $c->response->status(200);
}

sub rss : Local {
  my ($self, $c) = @_;

  my $project = $c->stash->{Project};

  my $rss = XML::RSS->new(version => '2.0');
  $rss->channel(
    title          => lc(Sys::Hostname::hostname()) . ' - ' . Gitalist->config->{name},
    link           => $c->uri_for('summary', {p=>$project->name}),
    language       => 'en',
    description    => $project->description,
    pubDate        => DateTime->now,
    lastBuildDate  => DateTime->now,
  );

  my %logargs = (
      sha1   => $project->head_hash,
      count  => Gitalist->config->{paging}{log} || 25,
      ($c->req->param('f') ? (file => $c->req->param('f')) : ())
  );
  my $mk_title = $c->stash->{short_cmt};
  for my $commit ($project->list_revs(%logargs)) {
    # XXX Needs work ....
    $rss->add_item(
        title       => $mk_title->($commit->comment),
        permaLink   => $c->uri_for(commit => {h=>$commit->sha1}),
        description => $commit->comment,
    );
  }

  $c->response->body($rss->as_string);
  $c->response->content_type('application/rss+xml');
  $c->response->status(200);
}

sub patch : Local {
    my ($self, $c) = @_;
    $c->detach('patches', [1]);
}

sub patches : Local {
    my ($self, $c, $count) = @_;
    $count ||= Gitalist->config->{patches}{max};
    my $commit = $self->_get_object($c);
    my $parent = $c->req->param('hp') || undef;
    my $patch = $commit->get_patch( $parent, $count );
    $c->response->body($patch);
    $c->response->content_type('text/plain');
    $c->response->status(200);
}

sub snapshot : Local {
    # FIXME - implement snapshot
    Carp::croak "Not implemented.";
}

=head2 auto

Populate the header and footer. Perhaps not the best location.

=cut

sub auto : Private {
  my($self, $c) = @_;

  my $project = $c->req->param('p');
  if (defined $project) {
    eval {
      $c->stash(Project => $c->model('GitRepos')->project($project));
    };
    if ($@) {
      $c->detach('error_404');
    }
  }

  my $a_project = $c->stash->{Project} || $c->model()->projects->[0];
  $c->stash(
    git_version => $a_project->run_cmd('--version'),
    version     => $Gitalist::VERSION,

    # XXX Move these to a plugin!
    time_since => sub {
      return 'never' unless $_[0];
      return age_string(time - $_[0]->epoch);
    },
    short_cmt => sub {
      my $cmt = shift;
      my($line) = split /\n/, $cmt;
      $line =~ s/^(.{70,80}\b).*/$1 …/;
      return $line;
    },
    abridged_description => sub {
        join(' ', grep { defined } (split / /, shift)[0..10]);
    },
  );
}

sub tags : Local {
    # FIXME - implement snapshot
    Carp::croak "Not implemented.";
}
sub project_index : Local {
    # FIXME - implement snapshot
    Carp::croak "Not implemented.";
}
sub opml : Local {
    # FIXME - implement snapshot
    Carp::croak "Not implemented.";
}
sub blame : Local {
    # FIXME - implement snapshot
    Carp::croak "Not implemented.";
}

=head2 end

Attempt to render a view, if needed.

=cut

sub end : ActionClass('RenderView') {
    my ($self, $c) = @_;
    # Give project views the current HEAD.
    if ($c->stash->{Project}) {
        $c->stash->{HEAD} = $c->stash->{Project}->head_hash;
    }
}

sub error_404 :Private {
    my ($self, $c) = @_;
    $c->response->status(404);
    $c->stash(
        title => 'Page not found',
        content => 'Page not found',
    );
}

sub age_string {
  my $age = shift;
  my $age_str;

  if ( $age > 60 * 60 * 24 * 365 * 2 ) {
    $age_str  = ( int $age / 60 / 60 / 24 / 365 );
    $age_str .= " years ago";
  }
  elsif ( $age > 60 * 60 * 24 * ( 365 / 12 ) * 2 ) {
    $age_str  = int $age / 60 / 60 / 24 / ( 365 / 12 );
    $age_str .= " months ago";
  }
  elsif ( $age > 60 * 60 * 24 * 7 * 2 ) {
    $age_str  = int $age / 60 / 60 / 24 / 7;
    $age_str .= " weeks ago";
  }
  elsif ( $age > 60 * 60 * 24 * 2 ) {
    $age_str  = int $age / 60 / 60 / 24;
    $age_str .= " days ago";
  }
  elsif ( $age > 60 * 60 * 2 ) {
    $age_str  = int $age / 60 / 60;
    $age_str .= " hours ago";
  }
  elsif ( $age > 60 * 2 ) {
    $age_str  = int $age / 60;
    $age_str .= " min ago";
  }
  elsif ( $age > 2 ) {
    $age_str  = int $age;
    $age_str .= " sec ago";
  }
  else {
    $age_str .= " right now";
  }
  return $age_str;
}


=head1 AUTHOR

Dan Brook

=head1 LICENSE

This library is free software. You can redistribute it and/or modify
it under the same terms as Perl itself.

=cut

__PACKAGE__->meta->make_immutable;
Commit	Line	Data
89de6a33	1	package Gitalist::Controller::Root;
42fe5d11	2	use Moose;
42fe5d11	3	use namespace::autoclean;
89de6a33	4
42fe5d11	5	BEGIN { extends 'Catalyst::Controller' }
89de6a33	6
89de6a33	7	__PACKAGE__->config->{namespace} = '';
89de6a33	8
d17ce39c	9	use IO::Capture::Stdout;
f796a861	10	use Sys::Hostname ();
d17ce39c	11	use XML::Atom::Feed;
d17ce39c	12	use XML::Atom::Entry;
f796a861	13	use XML::RSS;
d17ce39c	14
89de6a33	15	=head1 NAME
	16
	17	Gitalist::Controller::Root - Root Controller for Gitalist
	18
	19	=head1 DESCRIPTION
	20
	21	[enter your description here]
	22
	23	=head1 METHODS
	24
	25	=cut
	26
	27	=head2 index
	28
	29	=cut
	30
1625cd5f	31	=head2 run_gitweb
1625cd5f	32
f71a83ab	33	The C<gitweb> shim. It should now only be explicitly accessible by
f71a83ab	34	modifying the URL.
1625cd5f	35
	36	=cut
	37
e66db0fb	38	sub run_gitweb {
86382b95	39	my ( $self, $c ) = @_;
86382b95	40
e66db0fb	41	# XXX A slippery slope to be sure.
	42	if($c->req->param('a')) {
	43	my $capture = IO::Capture::Stdout->new();
	44	$capture->start();
	45	eval {
	46	my $action = gitweb::main($c);
	47	$action->();
	48	};
	49	$capture->stop();
5a2f0948	50
e66db0fb	51	use Data::Dumper;
	52	die Dumper($@)
	53	if $@;
5a2f0948	54
e66db0fb	55	my $output = join '', $capture->read;
	56	$c->stash->{gitweb_output} = $output;
	57	$c->stash->{template} = 'gitweb.tt2';
	58	}
86382b95	59	}
86382b95	60
832cbc81	61	sub _get_object {
b4b4d0fd	62	my($self, $c, $haveh) = @_;
9dc3b9a5	63
c1f608c8	64	my $h = $haveh \|\| $c->req->param('h') \|\| '';
0ee97fec	65	my $f = $c->req->param('f');
8dbe8024	66
1aad4e81	67	my $m = $c->stash->{Project};
1aad4e81	68	my $pd = $m->path;
0ee97fec	69
9dc3b9a5	70	# Either use the provided h(ash) parameter, the f(ile) parameter or just use HEAD.
a7cc1ede	71	my $hash = ($h =~ /[^a-f0-9]/ ? $m->head_hash($h) : $h)
	72	\|\| ($f && $m->hash_by_path($f))
	73	\|\| $m->head_hash
9dc3b9a5	74	# XXX This could definitely use more context.
	75	\|\| Carp::croak("Couldn't find a hash for the commit object!");
	76
a7cc1ede	77	my $commit = $m->get_object($hash)
a7cc1ede	78	or Carp::croak("Couldn't find a commit object for '$hash' in '$pd'!");
9dc3b9a5	79
	80	return $commit;
	81	}
	82
1625cd5f	83	=head2 index
	84
	85	Provides the project listing.
	86
	87	=cut
	88
86382b95	89	sub index :Path :Args(0) {
7bc165b3	90	my ( $self, $c ) = @_;
	91
	92	$c->detach($c->req->param('a'))
	93	if $c->req->param('a');
	94
	95	my @list = @{ $c->model()->projects };
	96	die 'No projects found in '. $c->model->repo_dir
	97	unless @list;
	98
	99	my $search = $c->req->param('s') \|\| '';
	100	if($search) {
	101	@list = grep {
	102	index($_->name, $search) > -1
	103	or ( $_->description !~ /^Unnamed repository/ and index($_->description, $search) > -1 )
	104	} @list
	105	}
	106
	107	$c->stash(
	108	search_text => $search,
	109	projects => \@list,
	110	action => 'index',
	111	);
04d1d917	112	}
04d1d917	113
790ce598	114	=head2 summary
	115
	116	A summary of what's happening in the repo.
	117
	118	=cut
	119
	120	sub summary : Local {
	121	my ( $self, $c ) = @_;
b47ae2c0	122	my $project = $c->stash->{Project};
3bbb1202	123	$c->detach('error_404') unless $project;
832cbc81	124	my $commit = $self->_get_object($c);
c65cccc2	125	my @heads = @{$project->heads};
06281e11	126	my $maxitems = Gitalist->config->{paging}{summary} \|\| 10;
790ce598	127	$c->stash(
790ce598	128	commit => $commit,
4111e151	129	log_lines => [$project->list_revs(
4111e151	130	sha1 => $commit->sha1,
06281e11	131	count => $maxitems,
fde5091f	132	)],
4111e151	133	refs => $project->references,
0969b411	134	heads => [ @heads[0 .. ($#heads < $maxitems ? $#heads : $maxitems)] ],
790ce598	135	action => 'summary',
06281e11	136	);
790ce598	137	}
	138
	139	=head2 heads
	140
	141	The current list of heads (aka branches) in the repo.
	142
	143	=cut
	144
	145	sub heads : Local {
	146	my ( $self, $c ) = @_;
b47ae2c0	147	my $project = $c->stash->{Project};
790ce598	148	$c->stash(
832cbc81	149	commit => $self->_get_object($c),
c65cccc2	150	heads => $project->heads,
790ce598	151	action => 'heads',
	152	);
	153	}
	154
1625cd5f	155	=head2 blob
	156
	157	The blob action i.e the contents of a file.
	158
	159	=cut
	160
295c9703	161	sub blob : Local {
295c9703	162	my ( $self, $c ) = @_;
8bb7649b	163	my $project = $c->stash->{Project};
c8870bd3	164	my $h = $c->req->param('h')
8bb7649b	165	\|\| $project->hash_by_path($c->req->param('hb'), $c->req->param('f'))
c8870bd3	166	\|\| die "No file or sha1 provided.";
c8870bd3	167	my $hb = $c->req->param('hb')
8bb7649b	168	\|\| $project->head_hash
c8870bd3	169	\|\| die "Couldn't discern the corresponding head.";
c8870bd3	170
f5da8e7a	171	my $filename = $c->req->param('f') \|\| '';
f5da8e7a	172
295c9703	173	$c->stash(
77b5d22c	174	blob => $project->get_object($h)->content,
8bb7649b	175	head => $project->get_object($hb),
f5da8e7a	176	filename => $filename,
	177	# XXX Hack hack hack, see View::SyntaxHighlight
	178	language => ($filename =~ /\.p[lm]$/ ? 'Perl' : ''),
c8870bd3	179	action => 'blob',
295c9703	180	);
7e54e579	181
c8a42dd5	182	$c->forward('View::SyntaxHighlight')
	183	unless $c->stash->{no_wrapper};
	184	}
	185
	186	sub blob_plain : Local {
	187	my($self, $c) = @_;
	188
	189	$c->stash(no_wrapper => 1);
	190	$c->response->content_type('text/plain; charset=utf-8');
	191
	192	$c->forward('blob');
	193	}
	194
	195	sub blobdiff_plain : Local {
	196	my($self, $c) = @_;
	197
	198	$c->stash(no_wrapper => 1);
	199	$c->response->content_type('text/plain; charset=utf-8');
	200
	201	$c->forward('blobdiff');
	202
295c9703	203	}
295c9703	204
6cf4366a	205	=head2 blobdiff
	206
	207	Exposes a given diff of a blob.
	208
	209	=cut
	210
	211	sub blobdiff : Local {
	212	my ( $self, $c ) = @_;
832cbc81	213	my $commit = $self->_get_object($c, $c->req->param('hb'));
6cf4366a	214	my $filename = $c->req->param('f')
6cf4366a	215	\|\| croak("No file specified!");
6cfcd548	216	my($tree, $patch) = $c->stash->{Project}->diff(
ad8884fc	217	commit => $commit,
ad8884fc	218	patch => 1,
c8a42dd5	219	parent => $c->req->param('hpb') \|\| undef,
c8a42dd5	220	file => $filename,
6cf4366a	221	);
	222	$c->stash(
	223	commit => $commit,
ad8884fc	224	diff => $patch,
6cf4366a	225	# XXX Hack hack hack, see View::SyntaxHighlight
ad8884fc	226	blobs => [$patch->[0]->{diff}],
6cf4366a	227	language => 'Diff',
	228	action => 'blobdiff',
	229	);
	230
c8a42dd5	231	$c->forward('View::SyntaxHighlight')
c8a42dd5	232	unless $c->stash->{no_wrapper};
6cf4366a	233	}
6cf4366a	234
1625cd5f	235	=head2 commit
1625cd5f	236
47495599	237	Exposes a given commit.
1625cd5f	238
	239	=cut
	240
1feb3d6b	241	sub commit : Local {
d7c9a32f	242	my ( $self, $c ) = @_;
77edf882	243	my $project = $c->stash->{Project};
832cbc81	244	my $commit = $self->_get_object($c);
b7aca93a	245	$c->stash(
790ce598	246	commit => $commit,
77edf882	247	diff_tree => ($project->diff(commit => $commit))[0],
77edf882	248	refs => $project->references,
790ce598	249	action => 'commit',
b7aca93a	250	);
d7c9a32f	251	}
d7c9a32f	252
2247133f	253	=head2 commitdiff
	254
	255	Exposes a given diff of a commit.
	256
	257	=cut
	258
	259	sub commitdiff : Local {
	260	my ( $self, $c ) = @_;
832cbc81	261	my $commit = $self->_get_object($c);
fc948aee	262	my($tree, $patch) = $c->stash->{Project}->diff(
ad8884fc	263	commit => $commit,
fc948aee	264	parent => $c->req->param('hp') \|\| undef,
ad8884fc	265	patch => 1,
ad8884fc	266	);
2247133f	267	$c->stash(
f5da8e7a	268	commit => $commit,
ad8884fc	269	diff_tree => $tree,
ad8884fc	270	diff => $patch,
f5da8e7a	271	# XXX Hack hack hack, see View::SyntaxHighlight
ad8884fc	272	blobs => [map $_->{diff}, @$patch],
f5da8e7a	273	language => 'Diff',
f5da8e7a	274	action => 'commitdiff',
2247133f	275	);
f5da8e7a	276
c8a42dd5	277	$c->forward('View::SyntaxHighlight')
	278	unless $c->stash->{no_wrapper};
	279	}
	280
	281	sub commitdiff_plain : Local {
	282	my($self, $c) = @_;
	283
	284	$c->stash(no_wrapper => 1);
	285	$c->response->content_type('text/plain; charset=utf-8');
	286
	287	$c->forward('commitdiff');
2247133f	288	}
2247133f	289
47495599	290	=head2 shortlog
	291
	292	Expose an abbreviated log of a given sha1.
	293
	294	=cut
	295
	296	sub shortlog : Local {
	297	my ( $self, $c ) = @_;
f740f8a9	298	my $project = $c->stash->{Project};
832cbc81	299	my $commit = $self->_get_object($c);
fde5091f	300	my %logargs = (
fde5091f	301	sha1 => $commit->sha1,
f740f8a9	302	count => Gitalist->config->{paging}{log} \|\| 25,
63e220b9	303	($c->req->param('f') ? (file => $c->req->param('f')) : ())
63e220b9	304	);
fde5091f	305
	306	my $page = $c->req->param('pg') \|\| 0;
	307	$logargs{skip} = $c->req->param('pg') * $logargs{count}
	308	if $c->req->param('pg');
	309
47495599	310	$c->stash(
790ce598	311	commit => $commit,
f740f8a9	312	log_lines => [$project->list_revs(%logargs)],
f740f8a9	313	refs => $project->references,
790ce598	314	action => 'shortlog',
b4b4d0fd	315	page => $page,
47495599	316	);
	317	}
	318
790ce598	319	=head2 log
	320
	321	Calls shortlog internally. Perhaps that should be reversed ...
	322
	323	=cut
	324	sub log : Local {
	325	$_[0]->shortlog($_[1]);
	326	$_[1]->stash->{action} = 'log';
	327	}
	328
c8a42dd5	329	# For legacy support.
	330	sub history : Local {
	331	$_[0]->shortlog(@_[1 .. $#_]);
	332	}
	333
b3fa97cd	334	=head2 tree
	335
	336	The tree of a given commit.
	337
	338	=cut
	339
	340	sub tree : Local {
	341	my ( $self, $c ) = @_;
74af77a3	342	my $project = $c->stash->{Project};
832cbc81	343	my $commit = $self->_get_object($c, $c->req->param('hb'));
832cbc81	344	my $tree = $self->_get_object($c, $c->req->param('h') \|\| $commit->tree_sha1);
b3fa97cd	345	$c->stash(
790ce598	346	commit => $commit,
b4b4d0fd	347	tree => $tree,
74af77a3	348	tree_list => [$project->list_tree($tree->sha1)],
832cbc81	349	path => $c->req->param('f') \|\| '',
790ce598	350	action => 'tree',
b3fa97cd	351	);
	352	}
	353
9dc3b9a5	354	=head2 reflog
	355
	356	Expose the local reflog. This may go away.
	357
	358	=cut
	359
	360	sub reflog : Local {
	361	my ( $self, $c ) = @_;
d8abdf1c	362	my @log = $c->stash->{Project}->reflog(
9dc3b9a5	363	'--since=yesterday'
	364	);
	365
	366	$c->stash(
	367	log => \@log,
	368	action => 'reflog',
	369	);
	370	}
	371
14664e1c	372	sub search : Local {
4df2f62f	373	my($self, $c) = @_;
d8abdf1c	374	$c->stash(current_action => 'GitRepos');
d8abdf1c	375	my $project = $c->stash->{Project};
832cbc81	376	my $commit = $self->_get_object($c);
4df2f62f	377	# Lifted from /shortlog.
	378	my %logargs = (
	379	sha1 => $commit->sha1,
	380	count => Gitalist->config->{paging}{log},
	381	($c->req->param('f') ? (file => $c->req->param('f')) : ()),
72d72d4d	382	search => {
	383	type => $c->req->param('type'),
	384	text => $c->req->param('text'),
	385	regexp => $c->req->param('regexp') \|\| 0,
	386	},
4df2f62f	387	);
	388
	389	$c->stash(
	390	commit => $commit,
d8abdf1c	391	results => [$project->list_revs(%logargs)],
4df2f62f	392	action => 'search',
	393	# This could be added - page => $page,
	394	);
14664e1c	395	}
	396
	397	sub search_help : Local {
2646511e	398	my ($self, $c) = @_;
2646511e	399	$c->stash(template => 'search_help.tt2');
6cfcd548	400	}
	401
	402	sub atom : Local {
d17ce39c	403	my($self, $c) = @_;
6cfcd548	404
d17ce39c	405	my $feed = XML::Atom::Feed->new;
6cfcd548	406
d17ce39c	407	my $host = lc Sys::Hostname::hostname();
	408	$feed->title($host . ' - ' . Gitalist->config->{name});
	409	$feed->updated(~~DateTime->now);
	410
	411	my $project = $c->stash->{Project};
	412	my %logargs = (
	413	sha1 => $project->head_hash,
	414	count => Gitalist->config->{paging}{log} \|\| 25,
	415	($c->req->param('f') ? (file => $c->req->param('f')) : ())
	416	);
	417
	418	my $mk_title = $c->stash->{short_cmt};
	419	for my $commit ($project->list_revs(%logargs)) {
	420	my $entry = XML::Atom::Entry->new;
	421	$entry->title( $mk_title->($commit->comment) );
	422	$entry->id($c->uri_for('commit', {h=>$commit->sha1}));
	423	# XXX Needs work ...
	424	$entry->content($commit->comment);
	425	$feed->add_entry($entry);
	426	}
	427
f796a861	428	$c->response->body($feed->as_xml);
e75df318	429	$c->response->content_type('application/atom+xml');
f796a861	430	$c->response->status(200);
6cfcd548	431	}
6cfcd548	432
6cfcd548	433	sub rss : Local {
f796a861	434	my ($self, $c) = @_;
	435
	436	my $project = $c->stash->{Project};
	437
	438	my $rss = XML::RSS->new(version => '2.0');
	439	$rss->channel(
	440	title => lc(Sys::Hostname::hostname()) . ' - ' . Gitalist->config->{name},
	441	link => $c->uri_for('summary', {p=>$project->name}),
	442	language => 'en',
	443	description => $project->description,
	444	pubDate => DateTime->now,
	445	lastBuildDate => DateTime->now,
	446	);
	447
	448	my %logargs = (
	449	sha1 => $project->head_hash,
	450	count => Gitalist->config->{paging}{log} \|\| 25,
	451	($c->req->param('f') ? (file => $c->req->param('f')) : ())
	452	);
	453	my $mk_title = $c->stash->{short_cmt};
	454	for my $commit ($project->list_revs(%logargs)) {
	455	# XXX Needs work ....
	456	$rss->add_item(
	457	title => $mk_title->($commit->comment),
	458	permaLink => $c->uri_for(commit => {h=>$commit->sha1}),
	459	description => $commit->comment,
	460	);
	461	}
	462
	463	$c->response->body($rss->as_string);
	464	$c->response->content_type('application/rss+xml');
	465	$c->response->status(200);
14664e1c	466	}
14664e1c	467
6cfcd548	468	sub patch : Local {
377bf360	469	my ($self, $c) = @_;
61ba8635	470	$c->detach('patches', [1]);
	471	}
	472
	473	sub patches : Local {
	474	my ($self, $c, $count) = @_;
	475	$count \|\|= Gitalist->config->{patches}{max};
377bf360	476	my $commit = $self->_get_object($c);
377bf360	477	my $parent = $c->req->param('hp') \|\| undef;
f707d264	478	my $patch = $commit->get_patch( $parent, $count );
377bf360	479	$c->response->body($patch);
	480	$c->response->content_type('text/plain');
	481	$c->response->status(200);
6cfcd548	482	}
6cfcd548	483
6cfcd548	484	sub snapshot : Local {
	485	# FIXME - implement snapshot
	486	Carp::croak "Not implemented.";
	487	}
	488
1625cd5f	489	=head2 auto
	490
	491	Populate the header and footer. Perhaps not the best location.
	492
	493	=cut
	494
04d1d917	495	sub auto : Private {
4621ecf0	496	my($self, $c) = @_;
04d1d917	497
da8f4f82	498	my $project = $c->req->param('p');
	499	if (defined $project) {
	500	eval {
	501	$c->stash(Project => $c->model('GitRepos')->project($project));
	502	};
	503	if ($@) {
	504	$c->detach('error_404');
	505	}
	506	}
	507
	508	my $a_project = $c->stash->{Project} \|\| $c->model()->projects->[0];
4621ecf0	509	$c->stash(
da8f4f82	510	git_version => $a_project->run_cmd('--version'),
	511	version => $Gitalist::VERSION,
	512
	513	# XXX Move these to a plugin!
4621ecf0	514	time_since => sub {
ef11b09e	515	return 'never' unless $_[0];
4621ecf0	516	return age_string(time - $_[0]->epoch);
	517	},
	518	short_cmt => sub {
	519	my $cmt = shift;
	520	my($line) = split /\n/, $cmt;
	521	$line =~ s/^(.{70,80}\b).*/$1 …/;
	522	return $line;
	523	},
5cd9b9f9	524	abridged_description => sub {
	525	join(' ', grep { defined } (split / /, shift)[0..10]);
	526	},
4621ecf0	527	);
04d1d917	528	}
d9a9b56b	529
77730637	530	sub tags : Local {
	531	# FIXME - implement snapshot
	532	Carp::croak "Not implemented.";
	533	}
	534	sub project_index : Local {
	535	# FIXME - implement snapshot
	536	Carp::croak "Not implemented.";
	537	}
	538	sub opml : Local {
	539	# FIXME - implement snapshot
	540	Carp::croak "Not implemented.";
	541	}
	542	sub blame : Local {
	543	# FIXME - implement snapshot
	544	Carp::croak "Not implemented.";
	545	}
	546
89de6a33	547	=head2 end
	548
	549	Attempt to render a view, if needed.
	550
	551	=cut
	552
fde5091f	553	sub end : ActionClass('RenderView') {
1aad4e81	554	my ($self, $c) = @_;
	555	# Give project views the current HEAD.
	556	if ($c->stash->{Project}) {
	557	$c->stash->{HEAD} = $c->stash->{Project}->head_hash;
	558	}
1fd8159c	559	}
d9a9b56b	560
4111e151	561	sub error_404 :Private {
	562	my ($self, $c) = @_;
	563	$c->response->status(404);
	564	$c->stash(
	565	title => 'Page not found',
	566	content => 'Page not found',
1aad4e81	567	);
4111e151	568	}
4111e151	569
1fd8159c	570	sub age_string {
da8f4f82	571	my $age = shift;
	572	my $age_str;
	573
	574	if ( $age > 60 * 60 * 24 * 365 * 2 ) {
	575	$age_str = ( int $age / 60 / 60 / 24 / 365 );
	576	$age_str .= " years ago";
	577	}
	578	elsif ( $age > 60 * 60 * 24 * ( 365 / 12 ) * 2 ) {
	579	$age_str = int $age / 60 / 60 / 24 / ( 365 / 12 );
	580	$age_str .= " months ago";
	581	}
	582	elsif ( $age > 60 * 60 * 24 * 7 * 2 ) {
	583	$age_str = int $age / 60 / 60 / 24 / 7;
	584	$age_str .= " weeks ago";
	585	}
	586	elsif ( $age > 60 * 60 * 24 * 2 ) {
	587	$age_str = int $age / 60 / 60 / 24;
	588	$age_str .= " days ago";
	589	}
	590	elsif ( $age > 60 * 60 * 2 ) {
	591	$age_str = int $age / 60 / 60;
	592	$age_str .= " hours ago";
	593	}
	594	elsif ( $age > 60 * 2 ) {
	595	$age_str = int $age / 60;
	596	$age_str .= " min ago";
	597	}
	598	elsif ( $age > 2 ) {
	599	$age_str = int $age;
	600	$age_str .= " sec ago";
	601	}
	602	else {
	603	$age_str .= " right now";
	604	}
	605	return $age_str;
7a88ffa4	606	}
7a88ffa4	607
da8f4f82	608
89de6a33	609	=head1 AUTHOR
89de6a33	610
f71a83ab	611	Dan Brook
89de6a33	612
	613	=head1 LICENSE
	614
	615	This library is free software. You can redistribute it and/or modify
	616	it under the same terms as Perl itself.
	617
	618	=cut
	619
42fe5d11	620	__PACKAGE__->meta->make_immutable;