2005-08-07 17:49:46 +00:00
|
|
|
#!/usr/bin/perl
|
|
|
|
|
2005-08-07 18:27:18 +00:00
|
|
|
# gitweb - simple web interface to track changes in git repositories
|
2005-08-07 17:56:59 +00:00
|
|
|
#
|
2006-05-22 12:30:47 +00:00
|
|
|
# (C) 2005-2006, Kay Sievers <kay.sievers@vrfy.org>
|
|
|
|
# (C) 2005, Christian Gierke
|
2005-08-07 17:57:58 +00:00
|
|
|
#
|
2005-10-03 23:12:47 +00:00
|
|
|
# This program is licensed under the GPLv2
|
2005-08-07 17:49:46 +00:00
|
|
|
|
|
|
|
use strict;
|
|
|
|
use warnings;
|
2005-08-07 18:26:27 +00:00
|
|
|
use CGI qw(:standard :escapeHTML -nosticky);
|
2005-08-07 18:23:49 +00:00
|
|
|
use CGI::Util qw(unescape);
|
2005-08-07 17:49:46 +00:00
|
|
|
use CGI::Carp qw(fatalsToBrowser);
|
replace invalid utf8 sequences by UTF-8 REPLACEMENT CHARACTER (efbfbd)
I still strongly disagree with the git maintainers not to hint people,
to use the only sane default encoding for a distributed project,
which is utf8. I'm tired of hearing filesystem development arguments.
Git is a software offered to merge forth and back across the world
and not to provide a content neutral filesystem.
Btw: I have nothing against the ability to run git in a closed environment,
with a different encoding, that's fine, sure. But that is obviously not
the case for the projects on kernel.org. It's about sane defaults,
nothing else.
You have to make decisions guy, as always in life. The problems to
allow random encoded garbage in commit messages _without_ storing
the encoding, just makes zero sense. Eighter you introduce a per-commit
encoding field, if you insist on this craziness, or you define a default
encoding. Everything else is just lazy and does not solve any problem,
besides that you can claim now, that you are not responsible for the mess
in the repository.
Gitweb shows several commits at once, you allow various encodings committed
to the same repository, without any hint what that garbage from the
individual commits is encoded with. No idea why you don't get
the problem - it's unsolvable. If you merge different peoples work, you
have to speak a common language!
Kay Sievers <kay.sievers@vrfy.org>
2005-11-19 16:41:29 +00:00
|
|
|
use Encode;
|
2005-08-07 18:21:04 +00:00
|
|
|
use Fcntl ':mode';
|
2006-08-01 02:18:34 +00:00
|
|
|
use File::Find qw();
|
2006-08-17 15:29:46 +00:00
|
|
|
use File::Basename qw(basename);
|
2005-11-23 03:26:40 +00:00
|
|
|
binmode STDOUT, ':utf8';
|
2005-08-07 17:49:46 +00:00
|
|
|
|
2006-12-27 23:00:52 +00:00
|
|
|
BEGIN {
|
|
|
|
CGI->compile() if $ENV{MOD_PERL};
|
|
|
|
}
|
|
|
|
|
2006-06-21 13:07:08 +00:00
|
|
|
our $cgi = new CGI;
|
2006-08-02 20:50:20 +00:00
|
|
|
our $version = "++GIT_VERSION++";
|
2006-06-21 13:07:08 +00:00
|
|
|
our $my_url = $cgi->url();
|
|
|
|
our $my_uri = $cgi->url(-absolute => 1);
|
2005-08-07 18:05:15 +00:00
|
|
|
|
2006-07-12 22:55:10 +00:00
|
|
|
# core git executable to use
|
|
|
|
# this can just be "git" if your webserver has a sensible PATH
|
2006-08-02 20:50:20 +00:00
|
|
|
our $GIT = "++GIT_BINDIR++/git";
|
2006-06-21 07:48:04 +00:00
|
|
|
|
2005-08-07 18:21:04 +00:00
|
|
|
# absolute fs-path which will be prepended to the project path
|
2006-06-21 13:07:08 +00:00
|
|
|
#our $projectroot = "/pub/scm";
|
2006-08-02 20:50:20 +00:00
|
|
|
our $projectroot = "++GITWEB_PROJECTROOT++";
|
2005-08-07 18:21:04 +00:00
|
|
|
|
|
|
|
# target of the home link on top of all pages
|
2006-08-16 22:28:39 +00:00
|
|
|
our $home_link = $my_uri || "/";
|
2005-08-07 18:21:04 +00:00
|
|
|
|
2006-08-14 22:50:49 +00:00
|
|
|
# string of the home link on top of all pages
|
|
|
|
our $home_link_str = "++GITWEB_HOME_LINK_STR++";
|
|
|
|
|
2006-07-11 20:10:26 +00:00
|
|
|
# name of your site or organization to appear in page titles
|
|
|
|
# replace this with something more descriptive for clearer bookmarks
|
2006-10-24 03:18:39 +00:00
|
|
|
our $site_name = "++GITWEB_SITENAME++"
|
|
|
|
|| ($ENV{'SERVER_NAME'} || "Untitled") . " Git";
|
2006-07-11 20:10:26 +00:00
|
|
|
|
2006-10-03 12:49:03 +00:00
|
|
|
# filename of html text to include at top of each page
|
|
|
|
our $site_header = "++GITWEB_SITE_HEADER++";
|
2005-08-07 18:22:53 +00:00
|
|
|
# html text to include at home page
|
2006-08-02 20:50:20 +00:00
|
|
|
our $home_text = "++GITWEB_HOMETEXT++";
|
2006-10-03 12:49:03 +00:00
|
|
|
# filename of html text to include at bottom of each page
|
|
|
|
our $site_footer = "++GITWEB_SITE_FOOTER++";
|
|
|
|
|
|
|
|
# URI of stylesheets
|
|
|
|
our @stylesheets = ("++GITWEB_CSS++");
|
2006-10-26 12:41:25 +00:00
|
|
|
# URI of a single stylesheet, which can be overridden in GITWEB_CONFIG.
|
|
|
|
our $stylesheet = undef;
|
2006-10-06 10:31:05 +00:00
|
|
|
# URI of GIT logo (72x27 size)
|
2006-08-02 20:50:20 +00:00
|
|
|
our $logo = "++GITWEB_LOGO++";
|
2006-09-04 18:32:13 +00:00
|
|
|
# URI of GIT favicon, assumed to be image/png type
|
|
|
|
our $favicon = "++GITWEB_FAVICON++";
|
2006-06-17 09:23:56 +00:00
|
|
|
|
2006-10-06 10:31:05 +00:00
|
|
|
# URI and label (title) of GIT logo link
|
|
|
|
#our $logo_url = "http://www.kernel.org/pub/software/scm/git/docs/";
|
|
|
|
#our $logo_label = "git documentation";
|
|
|
|
our $logo_url = "http://git.or.cz/";
|
|
|
|
our $logo_label = "git homepage";
|
2006-09-23 19:36:01 +00:00
|
|
|
|
2005-08-07 18:21:23 +00:00
|
|
|
# source of projects list
|
2006-08-02 20:50:20 +00:00
|
|
|
our $projects_list = "++GITWEB_LIST++";
|
2005-08-07 18:21:04 +00:00
|
|
|
|
2006-09-16 22:31:01 +00:00
|
|
|
# show repository only if this file exists
|
|
|
|
# (only effective if this variable evaluates to true)
|
|
|
|
our $export_ok = "++GITWEB_EXPORT_OK++";
|
|
|
|
|
|
|
|
# only allow viewing of repositories also shown on the overview page
|
|
|
|
our $strict_export = "++GITWEB_STRICT_EXPORT++";
|
|
|
|
|
2006-08-15 21:03:17 +00:00
|
|
|
# list of git base URLs used for URL to where fetch project from,
|
|
|
|
# i.e. full URL is "$git_base_url/$project"
|
2006-10-26 10:26:44 +00:00
|
|
|
our @git_base_url_list = grep { $_ ne '' } ("++GITWEB_BASE_URL++");
|
2006-08-15 21:03:17 +00:00
|
|
|
|
2006-06-17 11:32:15 +00:00
|
|
|
# default blob_plain mimetype and default charset for text/plain blob
|
2006-06-21 13:07:08 +00:00
|
|
|
our $default_blob_plain_mimetype = 'text/plain';
|
|
|
|
our $default_text_plain_charset = undef;
|
2006-06-17 11:32:15 +00:00
|
|
|
|
2006-06-17 22:01:06 +00:00
|
|
|
# file to use for guessing MIME types before trying /etc/mime.types
|
|
|
|
# (relative to the current git repository)
|
2006-06-21 13:07:08 +00:00
|
|
|
our $mimetypes_file = undef;
|
2006-06-17 22:01:06 +00:00
|
|
|
|
2006-08-20 06:23:04 +00:00
|
|
|
# You define site-wide feature defaults here; override them with
|
|
|
|
# $GITWEB_CONFIG as necessary.
|
2006-08-22 14:52:50 +00:00
|
|
|
our %feature = (
|
2006-08-26 17:14:22 +00:00
|
|
|
# feature => {
|
|
|
|
# 'sub' => feature-sub (subroutine),
|
|
|
|
# 'override' => allow-override (boolean),
|
|
|
|
# 'default' => [ default options...] (array reference)}
|
|
|
|
#
|
|
|
|
# if feature is overridable (it means that allow-override has true value,
|
|
|
|
# then feature-sub will be called with default options as parameters;
|
|
|
|
# return value of feature-sub indicates if to enable specified feature
|
|
|
|
#
|
|
|
|
# use gitweb_check_feature(<feature>) to check if <feature> is enabled
|
2006-08-22 14:52:50 +00:00
|
|
|
|
2006-10-07 13:17:47 +00:00
|
|
|
# Enable the 'blame' blob view, showing the last commit that modified
|
|
|
|
# each line in the file. This can be very CPU-intensive.
|
|
|
|
|
|
|
|
# To enable system wide have in $GITWEB_CONFIG
|
|
|
|
# $feature{'blame'}{'default'} = [1];
|
|
|
|
# To have project specific config enable override in $GITWEB_CONFIG
|
|
|
|
# $feature{'blame'}{'override'} = 1;
|
|
|
|
# and in project config gitweb.blame = 0|1;
|
2006-08-22 14:52:50 +00:00
|
|
|
'blame' => {
|
|
|
|
'sub' => \&feature_blame,
|
|
|
|
'override' => 0,
|
|
|
|
'default' => [0]},
|
|
|
|
|
2006-10-07 13:17:47 +00:00
|
|
|
# Enable the 'snapshot' link, providing a compressed tarball of any
|
|
|
|
# tree. This can potentially generate high traffic if you have large
|
|
|
|
# project.
|
|
|
|
|
|
|
|
# To disable system wide have in $GITWEB_CONFIG
|
|
|
|
# $feature{'snapshot'}{'default'} = [undef];
|
|
|
|
# To have project specific config enable override in $GITWEB_CONFIG
|
2006-12-08 11:44:31 +00:00
|
|
|
# $feature{'snapshot'}{'override'} = 1;
|
2006-10-07 13:17:47 +00:00
|
|
|
# and in project config gitweb.snapshot = none|gzip|bzip2;
|
2006-08-22 14:52:50 +00:00
|
|
|
'snapshot' => {
|
|
|
|
'sub' => \&feature_snapshot,
|
|
|
|
'override' => 0,
|
|
|
|
# => [content-encoding, suffix, program]
|
|
|
|
'default' => ['x-gzip', 'gz', 'gzip']},
|
2006-09-10 22:29:27 +00:00
|
|
|
|
2006-12-23 03:35:16 +00:00
|
|
|
# Enable text search, which will list the commits which match author,
|
|
|
|
# committer or commit text to a given string. Enabled by default.
|
|
|
|
'search' => {
|
|
|
|
'override' => 0,
|
|
|
|
'default' => [1]},
|
|
|
|
|
2006-10-07 13:17:47 +00:00
|
|
|
# Enable the pickaxe search, which will list the commits that modified
|
|
|
|
# a given string in a file. This can be practical and quite faster
|
|
|
|
# alternative to 'blame', but still potentially CPU-intensive.
|
|
|
|
|
|
|
|
# To enable system wide have in $GITWEB_CONFIG
|
|
|
|
# $feature{'pickaxe'}{'default'} = [1];
|
|
|
|
# To have project specific config enable override in $GITWEB_CONFIG
|
|
|
|
# $feature{'pickaxe'}{'override'} = 1;
|
|
|
|
# and in project config gitweb.pickaxe = 0|1;
|
2006-09-10 22:29:27 +00:00
|
|
|
'pickaxe' => {
|
|
|
|
'sub' => \&feature_pickaxe,
|
|
|
|
'override' => 0,
|
|
|
|
'default' => [1]},
|
2006-10-01 21:57:48 +00:00
|
|
|
|
2006-10-07 13:17:47 +00:00
|
|
|
# Make gitweb use an alternative format of the URLs which can be
|
|
|
|
# more readable and natural-looking: project name is embedded
|
|
|
|
# directly in the path and the query string contains other
|
|
|
|
# auxiliary information. All gitweb installations recognize
|
|
|
|
# URL in either format; this configures in which formats gitweb
|
|
|
|
# generates links.
|
|
|
|
|
|
|
|
# To enable system wide have in $GITWEB_CONFIG
|
|
|
|
# $feature{'pathinfo'}{'default'} = [1];
|
|
|
|
# Project specific override is not supported.
|
|
|
|
|
|
|
|
# Note that you will need to change the default location of CSS,
|
|
|
|
# favicon, logo and possibly other files to an absolute URL. Also,
|
|
|
|
# if gitweb.cgi serves as your indexfile, you will need to force
|
|
|
|
# $my_uri to contain the script name in your $GITWEB_CONFIG.
|
2006-10-01 21:57:48 +00:00
|
|
|
'pathinfo' => {
|
|
|
|
'override' => 0,
|
|
|
|
'default' => [0]},
|
2006-10-24 03:33:17 +00:00
|
|
|
|
|
|
|
# Make gitweb consider projects in project root subdirectories
|
|
|
|
# to be forks of existing projects. Given project $projname.git,
|
|
|
|
# projects matching $projname/*.git will not be shown in the main
|
|
|
|
# projects list, instead a '+' mark will be added to $projname
|
|
|
|
# there and a 'forks' view will be enabled for the project, listing
|
|
|
|
# all the forks. This feature is supported only if project list
|
|
|
|
# is taken from a directory, not file.
|
|
|
|
|
|
|
|
# To enable system wide have in $GITWEB_CONFIG
|
|
|
|
# $feature{'forks'}{'default'} = [1];
|
|
|
|
# Project specific override is not supported.
|
|
|
|
'forks' => {
|
|
|
|
'override' => 0,
|
|
|
|
'default' => [0]},
|
2006-08-20 06:23:04 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
sub gitweb_check_feature {
|
|
|
|
my ($name) = @_;
|
2006-09-25 23:56:17 +00:00
|
|
|
return unless exists $feature{$name};
|
2006-08-22 14:52:50 +00:00
|
|
|
my ($sub, $override, @defaults) = (
|
|
|
|
$feature{$name}{'sub'},
|
|
|
|
$feature{$name}{'override'},
|
|
|
|
@{$feature{$name}{'default'}});
|
2006-08-20 06:23:04 +00:00
|
|
|
if (!$override) { return @defaults; }
|
2006-10-03 18:07:43 +00:00
|
|
|
if (!defined $sub) {
|
|
|
|
warn "feature $name is not overrideable";
|
|
|
|
return @defaults;
|
|
|
|
}
|
2006-08-20 06:23:04 +00:00
|
|
|
return $sub->(@defaults);
|
|
|
|
}
|
|
|
|
|
|
|
|
sub feature_blame {
|
|
|
|
my ($val) = git_get_project_config('blame', '--bool');
|
|
|
|
|
|
|
|
if ($val eq 'true') {
|
|
|
|
return 1;
|
|
|
|
} elsif ($val eq 'false') {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return $_[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
sub feature_snapshot {
|
|
|
|
my ($ctype, $suffix, $command) = @_;
|
|
|
|
|
|
|
|
my ($val) = git_get_project_config('snapshot');
|
|
|
|
|
|
|
|
if ($val eq 'gzip') {
|
|
|
|
return ('x-gzip', 'gz', 'gzip');
|
|
|
|
} elsif ($val eq 'bzip2') {
|
|
|
|
return ('x-bzip2', 'bz2', 'bzip2');
|
|
|
|
} elsif ($val eq 'none') {
|
|
|
|
return ();
|
|
|
|
}
|
|
|
|
|
|
|
|
return ($ctype, $suffix, $command);
|
|
|
|
}
|
|
|
|
|
2006-09-28 23:49:21 +00:00
|
|
|
sub gitweb_have_snapshot {
|
|
|
|
my ($ctype, $suffix, $command) = gitweb_check_feature('snapshot');
|
|
|
|
my $have_snapshot = (defined $ctype && defined $suffix);
|
|
|
|
|
|
|
|
return $have_snapshot;
|
|
|
|
}
|
|
|
|
|
2006-09-10 22:29:27 +00:00
|
|
|
sub feature_pickaxe {
|
|
|
|
my ($val) = git_get_project_config('pickaxe', '--bool');
|
|
|
|
|
|
|
|
if ($val eq 'true') {
|
|
|
|
return (1);
|
|
|
|
} elsif ($val eq 'false') {
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ($_[0]);
|
|
|
|
}
|
|
|
|
|
2006-10-03 09:30:47 +00:00
|
|
|
# checking HEAD file with -e is fragile if the repository was
|
|
|
|
# initialized long time ago (i.e. symlink HEAD) and was pack-ref'ed
|
|
|
|
# and then pruned.
|
|
|
|
sub check_head_link {
|
|
|
|
my ($dir) = @_;
|
|
|
|
my $headfile = "$dir/HEAD";
|
|
|
|
return ((-e $headfile) ||
|
|
|
|
(-l $headfile && readlink($headfile) =~ /^refs\/heads\//));
|
|
|
|
}
|
|
|
|
|
|
|
|
sub check_export_ok {
|
|
|
|
my ($dir) = @_;
|
|
|
|
return (check_head_link($dir) &&
|
|
|
|
(!$export_ok || -e "$dir/$export_ok"));
|
|
|
|
}
|
|
|
|
|
2006-08-27 21:49:36 +00:00
|
|
|
# rename detection options for git-diff and git-diff-tree
|
|
|
|
# - default is '-M', with the cost proportional to
|
|
|
|
# (number of removed files) * (number of new files).
|
|
|
|
# - more costly is '-C' (or '-C', '-M'), with the cost proportional to
|
|
|
|
# (number of changed files + number of removed files) * (number of new files)
|
|
|
|
# - even more costly is '-C', '--find-copies-harder' with cost
|
|
|
|
# (number of files in the original tree) * (number of new files)
|
|
|
|
# - one might want to include '-B' option, e.g. '-B', '-M'
|
|
|
|
our @diff_opts = ('-M'); # taken from git_commit
|
|
|
|
|
2006-08-02 20:50:20 +00:00
|
|
|
our $GITWEB_CONFIG = $ENV{'GITWEB_CONFIG'} || "++GITWEB_CONFIG++";
|
2006-08-29 07:19:02 +00:00
|
|
|
do $GITWEB_CONFIG if -e $GITWEB_CONFIG;
|
2006-08-02 19:23:34 +00:00
|
|
|
|
|
|
|
# version of the core git binary
|
|
|
|
our $git_version = qx($GIT --version) =~ m/git version (.*)$/ ? $1 : "unknown";
|
|
|
|
|
|
|
|
$projects_list ||= $projectroot;
|
|
|
|
|
2006-08-05 10:55:20 +00:00
|
|
|
# ======================================================================
|
2005-08-07 18:21:23 +00:00
|
|
|
# input validation and dispatch
|
2006-06-21 13:07:08 +00:00
|
|
|
our $action = $cgi->param('a');
|
2005-08-07 18:21:23 +00:00
|
|
|
if (defined $action) {
|
2005-09-03 12:50:33 +00:00
|
|
|
if ($action =~ m/[^0-9a-zA-Z\.\-_]/) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Invalid action parameter");
|
2005-08-07 18:21:04 +00:00
|
|
|
}
|
|
|
|
}
|
2005-08-07 17:59:24 +00:00
|
|
|
|
2006-09-25 23:57:02 +00:00
|
|
|
# parameters which are pathnames
|
2006-09-16 21:08:32 +00:00
|
|
|
our $project = $cgi->param('p');
|
2006-08-16 22:28:40 +00:00
|
|
|
if (defined $project) {
|
2006-09-25 23:57:02 +00:00
|
|
|
if (!validate_pathname($project) ||
|
2006-09-16 22:30:27 +00:00
|
|
|
!(-d "$projectroot/$project") ||
|
2006-10-03 09:30:47 +00:00
|
|
|
!check_head_link("$projectroot/$project") ||
|
2006-09-16 22:31:01 +00:00
|
|
|
($export_ok && !(-e "$projectroot/$project/$export_ok")) ||
|
|
|
|
($strict_export && !project_in_list($project))) {
|
2006-09-16 22:30:27 +00:00
|
|
|
undef $project;
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "No such project");
|
2005-08-07 18:17:42 +00:00
|
|
|
}
|
2005-08-07 18:15:44 +00:00
|
|
|
}
|
2005-08-07 18:19:56 +00:00
|
|
|
|
2006-06-21 13:07:08 +00:00
|
|
|
our $file_name = $cgi->param('f');
|
2006-09-25 23:57:02 +00:00
|
|
|
if (defined $file_name) {
|
|
|
|
if (!validate_pathname($file_name)) {
|
|
|
|
die_error(undef, "Invalid file parameter");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-16 22:28:38 +00:00
|
|
|
our $file_parent = $cgi->param('fp');
|
2006-09-25 23:57:02 +00:00
|
|
|
if (defined $file_parent) {
|
|
|
|
if (!validate_pathname($file_parent)) {
|
|
|
|
die_error(undef, "Invalid file parent parameter");
|
|
|
|
}
|
|
|
|
}
|
2006-08-16 22:28:38 +00:00
|
|
|
|
2006-09-25 23:57:02 +00:00
|
|
|
# parameters which are refnames
|
2006-06-21 13:07:08 +00:00
|
|
|
our $hash = $cgi->param('h');
|
2005-08-07 18:27:38 +00:00
|
|
|
if (defined $hash) {
|
2006-09-25 23:57:02 +00:00
|
|
|
if (!validate_refname($hash)) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Invalid hash parameter");
|
2005-08-07 18:27:38 +00:00
|
|
|
}
|
2005-08-07 18:15:44 +00:00
|
|
|
}
|
2005-08-07 18:19:56 +00:00
|
|
|
|
2006-06-21 13:07:08 +00:00
|
|
|
our $hash_parent = $cgi->param('hp');
|
2005-09-03 12:50:33 +00:00
|
|
|
if (defined $hash_parent) {
|
2006-09-25 23:57:02 +00:00
|
|
|
if (!validate_refname($hash_parent)) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Invalid hash parent parameter");
|
2005-09-03 12:50:33 +00:00
|
|
|
}
|
2005-08-07 18:21:23 +00:00
|
|
|
}
|
|
|
|
|
2006-06-21 13:07:08 +00:00
|
|
|
our $hash_base = $cgi->param('hb');
|
2005-09-03 12:50:33 +00:00
|
|
|
if (defined $hash_base) {
|
2006-09-25 23:57:02 +00:00
|
|
|
if (!validate_refname($hash_base)) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Invalid hash base parameter");
|
2005-09-03 12:50:33 +00:00
|
|
|
}
|
2005-08-07 18:15:44 +00:00
|
|
|
}
|
2005-08-07 18:19:56 +00:00
|
|
|
|
2006-08-24 21:53:54 +00:00
|
|
|
our $hash_parent_base = $cgi->param('hpb');
|
|
|
|
if (defined $hash_parent_base) {
|
2006-09-25 23:57:02 +00:00
|
|
|
if (!validate_refname($hash_parent_base)) {
|
2006-08-24 21:53:54 +00:00
|
|
|
die_error(undef, "Invalid hash parent base parameter");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-25 23:57:02 +00:00
|
|
|
# other parameters
|
2006-06-21 13:07:08 +00:00
|
|
|
our $page = $cgi->param('pg');
|
2005-08-07 18:26:49 +00:00
|
|
|
if (defined $page) {
|
2006-09-17 11:52:45 +00:00
|
|
|
if ($page =~ m/[^0-9]/) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Invalid page parameter");
|
2005-08-07 18:21:04 +00:00
|
|
|
}
|
2005-08-07 18:14:48 +00:00
|
|
|
}
|
2005-08-07 17:57:58 +00:00
|
|
|
|
2006-06-21 13:07:08 +00:00
|
|
|
our $searchtext = $cgi->param('s');
|
2005-08-07 18:26:27 +00:00
|
|
|
if (defined $searchtext) {
|
|
|
|
if ($searchtext =~ m/[^a-zA-Z0-9_\.\/\-\+\:\@ ]/) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Invalid search parameter");
|
2005-08-07 18:26:27 +00:00
|
|
|
}
|
2006-12-23 03:35:15 +00:00
|
|
|
if (length($searchtext) < 2) {
|
|
|
|
die_error(undef, "At least two characters are required for search parameter");
|
|
|
|
}
|
2005-08-07 18:26:27 +00:00
|
|
|
$searchtext = quotemeta $searchtext;
|
|
|
|
}
|
|
|
|
|
2006-10-24 03:15:46 +00:00
|
|
|
our $searchtype = $cgi->param('st');
|
|
|
|
if (defined $searchtype) {
|
|
|
|
if ($searchtype =~ m/[^a-z]/) {
|
|
|
|
die_error(undef, "Invalid searchtype parameter");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-16 21:08:32 +00:00
|
|
|
# now read PATH_INFO and use it as alternative to parameters
|
2006-09-17 13:29:48 +00:00
|
|
|
sub evaluate_path_info {
|
|
|
|
return if defined $project;
|
|
|
|
my $path_info = $ENV{"PATH_INFO"};
|
|
|
|
return if !$path_info;
|
gitweb: Even more support for PATH_INFO based URLs
Now the following types of path based URLs are supported:
* project overview (summary) page of project
* project/branch shortlog of branch
* project/branch:file file in branch, blob_plain view
* project/branch:dir/ directory listing of dir in branch, tree view
The following shortcuts works (see explanation below):
* project/branch: directory listing of branch, main tree view
* project/:file file in HEAD (raw)
* project/:dir/ directory listing of dir in HEAD
* project/: directory listing of project's HEAD
We use ':' as separator between branch (ref) name and file name
(pathname) because valid branch (ref) name cannot have ':' inside.
This limit applies to branch name only. This allow for hierarchical
branches e.g. topic branch 'topic/subtopic', separate remotes
tracking branches e.g. 'refs/remotes/origin/HEAD', and discriminate
between head (branch) and tag with the same name.
Empty branch should be interpreted as HEAD.
If pathname (the part after ':') ends with '/', we assume that pathname
is name of directory, and we want to show contents of said directory
using "tree" view. If pathname is empty, it is equivalent to '/' (top
directory).
If pathname (the part after ':') does not end with '/', we assume that
pathname is name of file, and we show contents of said file using
"blob_plain" view.
Pathname is stripped of leading '/', so we can use ':/' to separate
branch from pathname. The rationale behind support for PATH_INFO based
URLs was to support project web pages for small projects: just create
an html branch and then use an URL like
http://nowhere.com/gitweb.cgi/project.git/html:/index.html
The ':/' syntax allow for working links between .html files served
in such way, e.g. <a href="main.html"> link inside "index.html"
would get
http://nowhere.com/gitweb.cgi/project.git/html:/main.html.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-19 22:49:51 +00:00
|
|
|
$path_info =~ s,^/+,,;
|
2006-09-17 13:29:48 +00:00
|
|
|
return if !$path_info;
|
gitweb: Even more support for PATH_INFO based URLs
Now the following types of path based URLs are supported:
* project overview (summary) page of project
* project/branch shortlog of branch
* project/branch:file file in branch, blob_plain view
* project/branch:dir/ directory listing of dir in branch, tree view
The following shortcuts works (see explanation below):
* project/branch: directory listing of branch, main tree view
* project/:file file in HEAD (raw)
* project/:dir/ directory listing of dir in HEAD
* project/: directory listing of project's HEAD
We use ':' as separator between branch (ref) name and file name
(pathname) because valid branch (ref) name cannot have ':' inside.
This limit applies to branch name only. This allow for hierarchical
branches e.g. topic branch 'topic/subtopic', separate remotes
tracking branches e.g. 'refs/remotes/origin/HEAD', and discriminate
between head (branch) and tag with the same name.
Empty branch should be interpreted as HEAD.
If pathname (the part after ':') ends with '/', we assume that pathname
is name of directory, and we want to show contents of said directory
using "tree" view. If pathname is empty, it is equivalent to '/' (top
directory).
If pathname (the part after ':') does not end with '/', we assume that
pathname is name of file, and we show contents of said file using
"blob_plain" view.
Pathname is stripped of leading '/', so we can use ':/' to separate
branch from pathname. The rationale behind support for PATH_INFO based
URLs was to support project web pages for small projects: just create
an html branch and then use an URL like
http://nowhere.com/gitweb.cgi/project.git/html:/index.html
The ':/' syntax allow for working links between .html files served
in such way, e.g. <a href="main.html"> link inside "index.html"
would get
http://nowhere.com/gitweb.cgi/project.git/html:/main.html.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-19 22:49:51 +00:00
|
|
|
# find which part of PATH_INFO is project
|
2006-09-16 21:08:32 +00:00
|
|
|
$project = $path_info;
|
gitweb: Even more support for PATH_INFO based URLs
Now the following types of path based URLs are supported:
* project overview (summary) page of project
* project/branch shortlog of branch
* project/branch:file file in branch, blob_plain view
* project/branch:dir/ directory listing of dir in branch, tree view
The following shortcuts works (see explanation below):
* project/branch: directory listing of branch, main tree view
* project/:file file in HEAD (raw)
* project/:dir/ directory listing of dir in HEAD
* project/: directory listing of project's HEAD
We use ':' as separator between branch (ref) name and file name
(pathname) because valid branch (ref) name cannot have ':' inside.
This limit applies to branch name only. This allow for hierarchical
branches e.g. topic branch 'topic/subtopic', separate remotes
tracking branches e.g. 'refs/remotes/origin/HEAD', and discriminate
between head (branch) and tag with the same name.
Empty branch should be interpreted as HEAD.
If pathname (the part after ':') ends with '/', we assume that pathname
is name of directory, and we want to show contents of said directory
using "tree" view. If pathname is empty, it is equivalent to '/' (top
directory).
If pathname (the part after ':') does not end with '/', we assume that
pathname is name of file, and we show contents of said file using
"blob_plain" view.
Pathname is stripped of leading '/', so we can use ':/' to separate
branch from pathname. The rationale behind support for PATH_INFO based
URLs was to support project web pages for small projects: just create
an html branch and then use an URL like
http://nowhere.com/gitweb.cgi/project.git/html:/index.html
The ':/' syntax allow for working links between .html files served
in such way, e.g. <a href="main.html"> link inside "index.html"
would get
http://nowhere.com/gitweb.cgi/project.git/html:/main.html.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-19 22:49:51 +00:00
|
|
|
$project =~ s,/+$,,;
|
2006-10-03 09:30:47 +00:00
|
|
|
while ($project && !check_head_link("$projectroot/$project")) {
|
2006-09-16 21:08:32 +00:00
|
|
|
$project =~ s,/*[^/]*$,,;
|
|
|
|
}
|
gitweb: Even more support for PATH_INFO based URLs
Now the following types of path based URLs are supported:
* project overview (summary) page of project
* project/branch shortlog of branch
* project/branch:file file in branch, blob_plain view
* project/branch:dir/ directory listing of dir in branch, tree view
The following shortcuts works (see explanation below):
* project/branch: directory listing of branch, main tree view
* project/:file file in HEAD (raw)
* project/:dir/ directory listing of dir in HEAD
* project/: directory listing of project's HEAD
We use ':' as separator between branch (ref) name and file name
(pathname) because valid branch (ref) name cannot have ':' inside.
This limit applies to branch name only. This allow for hierarchical
branches e.g. topic branch 'topic/subtopic', separate remotes
tracking branches e.g. 'refs/remotes/origin/HEAD', and discriminate
between head (branch) and tag with the same name.
Empty branch should be interpreted as HEAD.
If pathname (the part after ':') ends with '/', we assume that pathname
is name of directory, and we want to show contents of said directory
using "tree" view. If pathname is empty, it is equivalent to '/' (top
directory).
If pathname (the part after ':') does not end with '/', we assume that
pathname is name of file, and we show contents of said file using
"blob_plain" view.
Pathname is stripped of leading '/', so we can use ':/' to separate
branch from pathname. The rationale behind support for PATH_INFO based
URLs was to support project web pages for small projects: just create
an html branch and then use an URL like
http://nowhere.com/gitweb.cgi/project.git/html:/index.html
The ':/' syntax allow for working links between .html files served
in such way, e.g. <a href="main.html"> link inside "index.html"
would get
http://nowhere.com/gitweb.cgi/project.git/html:/main.html.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-19 22:49:51 +00:00
|
|
|
# validate project
|
2006-09-25 23:57:02 +00:00
|
|
|
$project = validate_pathname($project);
|
2006-09-17 13:29:48 +00:00
|
|
|
if (!$project ||
|
|
|
|
($export_ok && !-e "$projectroot/$project/$export_ok") ||
|
|
|
|
($strict_export && !project_in_list($project))) {
|
|
|
|
undef $project;
|
|
|
|
return;
|
2006-09-16 21:08:32 +00:00
|
|
|
}
|
2006-09-17 13:29:48 +00:00
|
|
|
# do not change any parameters if an action is given using the query string
|
|
|
|
return if $action;
|
gitweb: Even more support for PATH_INFO based URLs
Now the following types of path based URLs are supported:
* project overview (summary) page of project
* project/branch shortlog of branch
* project/branch:file file in branch, blob_plain view
* project/branch:dir/ directory listing of dir in branch, tree view
The following shortcuts works (see explanation below):
* project/branch: directory listing of branch, main tree view
* project/:file file in HEAD (raw)
* project/:dir/ directory listing of dir in HEAD
* project/: directory listing of project's HEAD
We use ':' as separator between branch (ref) name and file name
(pathname) because valid branch (ref) name cannot have ':' inside.
This limit applies to branch name only. This allow for hierarchical
branches e.g. topic branch 'topic/subtopic', separate remotes
tracking branches e.g. 'refs/remotes/origin/HEAD', and discriminate
between head (branch) and tag with the same name.
Empty branch should be interpreted as HEAD.
If pathname (the part after ':') ends with '/', we assume that pathname
is name of directory, and we want to show contents of said directory
using "tree" view. If pathname is empty, it is equivalent to '/' (top
directory).
If pathname (the part after ':') does not end with '/', we assume that
pathname is name of file, and we show contents of said file using
"blob_plain" view.
Pathname is stripped of leading '/', so we can use ':/' to separate
branch from pathname. The rationale behind support for PATH_INFO based
URLs was to support project web pages for small projects: just create
an html branch and then use an URL like
http://nowhere.com/gitweb.cgi/project.git/html:/index.html
The ':/' syntax allow for working links between .html files served
in such way, e.g. <a href="main.html"> link inside "index.html"
would get
http://nowhere.com/gitweb.cgi/project.git/html:/main.html.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-19 22:49:51 +00:00
|
|
|
$path_info =~ s,^$project/*,,;
|
|
|
|
my ($refname, $pathname) = split(/:/, $path_info, 2);
|
|
|
|
if (defined $pathname) {
|
|
|
|
# we got "project.git/branch:filename" or "project.git/branch:dir/"
|
|
|
|
# we could use git_get_type(branch:pathname), but it needs $git_dir
|
|
|
|
$pathname =~ s,^/+,,;
|
|
|
|
if (!$pathname || substr($pathname, -1) eq "/") {
|
|
|
|
$action ||= "tree";
|
2006-09-21 07:48:21 +00:00
|
|
|
$pathname =~ s,/$,,;
|
gitweb: Even more support for PATH_INFO based URLs
Now the following types of path based URLs are supported:
* project overview (summary) page of project
* project/branch shortlog of branch
* project/branch:file file in branch, blob_plain view
* project/branch:dir/ directory listing of dir in branch, tree view
The following shortcuts works (see explanation below):
* project/branch: directory listing of branch, main tree view
* project/:file file in HEAD (raw)
* project/:dir/ directory listing of dir in HEAD
* project/: directory listing of project's HEAD
We use ':' as separator between branch (ref) name and file name
(pathname) because valid branch (ref) name cannot have ':' inside.
This limit applies to branch name only. This allow for hierarchical
branches e.g. topic branch 'topic/subtopic', separate remotes
tracking branches e.g. 'refs/remotes/origin/HEAD', and discriminate
between head (branch) and tag with the same name.
Empty branch should be interpreted as HEAD.
If pathname (the part after ':') ends with '/', we assume that pathname
is name of directory, and we want to show contents of said directory
using "tree" view. If pathname is empty, it is equivalent to '/' (top
directory).
If pathname (the part after ':') does not end with '/', we assume that
pathname is name of file, and we show contents of said file using
"blob_plain" view.
Pathname is stripped of leading '/', so we can use ':/' to separate
branch from pathname. The rationale behind support for PATH_INFO based
URLs was to support project web pages for small projects: just create
an html branch and then use an URL like
http://nowhere.com/gitweb.cgi/project.git/html:/index.html
The ':/' syntax allow for working links between .html files served
in such way, e.g. <a href="main.html"> link inside "index.html"
would get
http://nowhere.com/gitweb.cgi/project.git/html:/main.html.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-19 22:49:51 +00:00
|
|
|
} else {
|
|
|
|
$action ||= "blob_plain";
|
|
|
|
}
|
2006-09-25 23:57:02 +00:00
|
|
|
$hash_base ||= validate_refname($refname);
|
|
|
|
$file_name ||= validate_pathname($pathname);
|
gitweb: Even more support for PATH_INFO based URLs
Now the following types of path based URLs are supported:
* project overview (summary) page of project
* project/branch shortlog of branch
* project/branch:file file in branch, blob_plain view
* project/branch:dir/ directory listing of dir in branch, tree view
The following shortcuts works (see explanation below):
* project/branch: directory listing of branch, main tree view
* project/:file file in HEAD (raw)
* project/:dir/ directory listing of dir in HEAD
* project/: directory listing of project's HEAD
We use ':' as separator between branch (ref) name and file name
(pathname) because valid branch (ref) name cannot have ':' inside.
This limit applies to branch name only. This allow for hierarchical
branches e.g. topic branch 'topic/subtopic', separate remotes
tracking branches e.g. 'refs/remotes/origin/HEAD', and discriminate
between head (branch) and tag with the same name.
Empty branch should be interpreted as HEAD.
If pathname (the part after ':') ends with '/', we assume that pathname
is name of directory, and we want to show contents of said directory
using "tree" view. If pathname is empty, it is equivalent to '/' (top
directory).
If pathname (the part after ':') does not end with '/', we assume that
pathname is name of file, and we show contents of said file using
"blob_plain" view.
Pathname is stripped of leading '/', so we can use ':/' to separate
branch from pathname. The rationale behind support for PATH_INFO based
URLs was to support project web pages for small projects: just create
an html branch and then use an URL like
http://nowhere.com/gitweb.cgi/project.git/html:/index.html
The ':/' syntax allow for working links between .html files served
in such way, e.g. <a href="main.html"> link inside "index.html"
would get
http://nowhere.com/gitweb.cgi/project.git/html:/main.html.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-19 22:49:51 +00:00
|
|
|
} elsif (defined $refname) {
|
2006-09-16 21:08:32 +00:00
|
|
|
# we got "project.git/branch"
|
|
|
|
$action ||= "shortlog";
|
2006-09-25 23:57:02 +00:00
|
|
|
$hash ||= validate_refname($refname);
|
2006-09-16 21:08:32 +00:00
|
|
|
}
|
|
|
|
}
|
2006-09-17 13:29:48 +00:00
|
|
|
evaluate_path_info();
|
2006-09-16 21:08:32 +00:00
|
|
|
|
2006-09-17 13:29:48 +00:00
|
|
|
# path to the current git repository
|
|
|
|
our $git_dir;
|
|
|
|
$git_dir = "$projectroot/$project" if $project;
|
2006-09-16 21:08:32 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
# dispatch
|
2006-07-31 21:46:25 +00:00
|
|
|
my %actions = (
|
|
|
|
"blame" => \&git_blame2,
|
|
|
|
"blobdiff" => \&git_blobdiff,
|
|
|
|
"blobdiff_plain" => \&git_blobdiff_plain,
|
|
|
|
"blob" => \&git_blob,
|
|
|
|
"blob_plain" => \&git_blob_plain,
|
|
|
|
"commitdiff" => \&git_commitdiff,
|
|
|
|
"commitdiff_plain" => \&git_commitdiff_plain,
|
|
|
|
"commit" => \&git_commit,
|
2006-10-24 03:33:17 +00:00
|
|
|
"forks" => \&git_forks,
|
2006-07-31 21:46:25 +00:00
|
|
|
"heads" => \&git_heads,
|
|
|
|
"history" => \&git_history,
|
|
|
|
"log" => \&git_log,
|
|
|
|
"rss" => \&git_rss,
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
"atom" => \&git_atom,
|
2006-07-31 21:46:25 +00:00
|
|
|
"search" => \&git_search,
|
2006-10-24 03:15:46 +00:00
|
|
|
"search_help" => \&git_search_help,
|
2006-07-31 21:46:25 +00:00
|
|
|
"shortlog" => \&git_shortlog,
|
|
|
|
"summary" => \&git_summary,
|
|
|
|
"tag" => \&git_tag,
|
|
|
|
"tags" => \&git_tags,
|
|
|
|
"tree" => \&git_tree,
|
2006-08-17 15:29:46 +00:00
|
|
|
"snapshot" => \&git_snapshot,
|
2006-12-10 12:25:47 +00:00
|
|
|
"object" => \&git_object,
|
2006-08-22 14:59:20 +00:00
|
|
|
# those below don't need $project
|
|
|
|
"opml" => \&git_opml,
|
|
|
|
"project_list" => \&git_project_list,
|
2006-09-15 02:56:03 +00:00
|
|
|
"project_index" => \&git_project_index,
|
2006-07-31 21:46:25 +00:00
|
|
|
);
|
|
|
|
|
2006-08-22 14:59:20 +00:00
|
|
|
if (defined $project) {
|
|
|
|
$action ||= 'summary';
|
|
|
|
} else {
|
|
|
|
$action ||= 'project_list';
|
|
|
|
}
|
2006-07-31 21:46:25 +00:00
|
|
|
if (!defined($actions{$action})) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Unknown action");
|
2005-08-07 18:21:23 +00:00
|
|
|
}
|
2006-09-19 19:53:22 +00:00
|
|
|
if ($action !~ m/^(opml|project_list|project_index)$/ &&
|
|
|
|
!$project) {
|
|
|
|
die_error(undef, "Project needed");
|
|
|
|
}
|
2006-07-31 21:46:25 +00:00
|
|
|
$actions{$action}->();
|
|
|
|
exit;
|
2005-08-07 18:21:23 +00:00
|
|
|
|
2006-08-15 22:23:50 +00:00
|
|
|
## ======================================================================
|
|
|
|
## action links
|
|
|
|
|
|
|
|
sub href(%) {
|
2006-08-22 17:05:25 +00:00
|
|
|
my %params = @_;
|
2006-11-19 14:05:21 +00:00
|
|
|
# default is to use -absolute url() i.e. $my_uri
|
|
|
|
my $href = $params{-full} ? $my_url : $my_uri;
|
2006-08-22 17:05:25 +00:00
|
|
|
|
2006-10-11 20:31:15 +00:00
|
|
|
# XXX: Warning: If you touch this, check the search form for updating,
|
|
|
|
# too.
|
2006-08-22 17:05:25 +00:00
|
|
|
|
|
|
|
my @mapping = (
|
2006-08-15 22:23:50 +00:00
|
|
|
project => "p",
|
2006-08-24 21:53:54 +00:00
|
|
|
action => "a",
|
2006-08-15 22:23:50 +00:00
|
|
|
file_name => "f",
|
2006-08-16 22:28:38 +00:00
|
|
|
file_parent => "fp",
|
2006-08-15 22:23:50 +00:00
|
|
|
hash => "h",
|
|
|
|
hash_parent => "hp",
|
|
|
|
hash_base => "hb",
|
2006-08-24 21:53:54 +00:00
|
|
|
hash_parent_base => "hpb",
|
2006-08-15 22:23:50 +00:00
|
|
|
page => "pg",
|
2006-09-15 17:30:34 +00:00
|
|
|
order => "o",
|
2006-08-15 22:23:50 +00:00
|
|
|
searchtext => "s",
|
2006-10-24 03:15:46 +00:00
|
|
|
searchtype => "st",
|
2006-08-15 22:23:50 +00:00
|
|
|
);
|
2006-08-22 17:05:25 +00:00
|
|
|
my %mapping = @mapping;
|
2006-08-15 22:23:50 +00:00
|
|
|
|
2006-09-15 17:30:34 +00:00
|
|
|
$params{'project'} = $project unless exists $params{'project'};
|
2006-08-15 22:23:50 +00:00
|
|
|
|
2006-10-01 21:57:48 +00:00
|
|
|
my ($use_pathinfo) = gitweb_check_feature('pathinfo');
|
|
|
|
if ($use_pathinfo) {
|
|
|
|
# use PATH_INFO for project name
|
|
|
|
$href .= "/$params{'project'}" if defined $params{'project'};
|
|
|
|
delete $params{'project'};
|
|
|
|
|
|
|
|
# Summary just uses the project path URL
|
|
|
|
if (defined $params{'action'} && $params{'action'} eq 'summary') {
|
|
|
|
delete $params{'action'};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
# now encode the parameters explicitly
|
2006-08-22 17:05:25 +00:00
|
|
|
my @result = ();
|
|
|
|
for (my $i = 0; $i < @mapping; $i += 2) {
|
|
|
|
my ($name, $symbol) = ($mapping[$i], $mapping[$i+1]);
|
|
|
|
if (defined $params{$name}) {
|
|
|
|
push @result, $symbol . "=" . esc_param($params{$name});
|
|
|
|
}
|
|
|
|
}
|
2006-10-01 21:57:48 +00:00
|
|
|
$href .= "?" . join(';', @result) if scalar @result;
|
|
|
|
|
|
|
|
return $href;
|
2006-08-15 22:23:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ======================================================================
|
|
|
|
## validation, quoting/unquoting and escaping
|
|
|
|
|
2006-09-25 23:57:02 +00:00
|
|
|
sub validate_pathname {
|
|
|
|
my $input = shift || return undef;
|
2006-07-31 19:22:15 +00:00
|
|
|
|
2006-09-25 23:57:02 +00:00
|
|
|
# no '.' or '..' as elements of path, i.e. no '.' nor '..'
|
|
|
|
# at the beginning, at the end, and between slashes.
|
|
|
|
# also this catches doubled slashes
|
|
|
|
if ($input =~ m!(^|/)(|\.|\.\.)(/|$)!) {
|
|
|
|
return undef;
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
2006-09-25 23:57:02 +00:00
|
|
|
# no null characters
|
|
|
|
if ($input =~ m!\0!) {
|
2006-07-31 19:22:15 +00:00
|
|
|
return undef;
|
|
|
|
}
|
2006-09-25 23:57:02 +00:00
|
|
|
return $input;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub validate_refname {
|
|
|
|
my $input = shift || return undef;
|
|
|
|
|
|
|
|
# textual hashes are O.K.
|
|
|
|
if ($input =~ m/^[0-9a-fA-F]{40}$/) {
|
|
|
|
return $input;
|
|
|
|
}
|
|
|
|
# it must be correct pathname
|
|
|
|
$input = validate_pathname($input)
|
|
|
|
or return undef;
|
|
|
|
# restrictions on ref name according to git-check-ref-format
|
|
|
|
if ($input =~ m!(/\.|\.\.|[\000-\040\177 ~^:?*\[]|/$)!) {
|
2006-07-31 19:22:15 +00:00
|
|
|
return undef;
|
|
|
|
}
|
|
|
|
return $input;
|
|
|
|
}
|
|
|
|
|
2006-10-01 21:21:33 +00:00
|
|
|
# very thin wrapper for decode("utf8", $str, Encode::FB_DEFAULT);
|
|
|
|
sub to_utf8 {
|
|
|
|
my $str = shift;
|
|
|
|
return decode("utf8", $str, Encode::FB_DEFAULT);
|
|
|
|
}
|
|
|
|
|
2005-11-24 15:56:55 +00:00
|
|
|
# quote unsafe chars, but keep the slash, even when it's not
|
|
|
|
# correct, but quoted slashes look too horrible in bookmarks
|
|
|
|
sub esc_param {
|
2005-11-14 04:47:18 +00:00
|
|
|
my $str = shift;
|
2006-09-23 22:18:41 +00:00
|
|
|
$str =~ s/([^A-Za-z0-9\-_.~()\/:@])/sprintf("%%%02X", ord($1))/eg;
|
2005-11-14 05:10:07 +00:00
|
|
|
$str =~ s/\+/%2B/g;
|
2005-11-14 14:15:12 +00:00
|
|
|
$str =~ s/ /\+/g;
|
2005-11-14 04:47:18 +00:00
|
|
|
return $str;
|
|
|
|
}
|
|
|
|
|
2006-09-25 23:58:41 +00:00
|
|
|
# quote unsafe chars in whole URL, so some charactrs cannot be quoted
|
|
|
|
sub esc_url {
|
|
|
|
my $str = shift;
|
|
|
|
$str =~ s/([^A-Za-z0-9\-_.~();\/;?:@&=])/sprintf("%%%02X", ord($1))/eg;
|
|
|
|
$str =~ s/\+/%2B/g;
|
|
|
|
$str =~ s/ /\+/g;
|
|
|
|
return $str;
|
|
|
|
}
|
|
|
|
|
2005-11-24 15:56:55 +00:00
|
|
|
# replace invalid utf8 character with SUBSTITUTION sequence
|
2006-11-01 13:33:21 +00:00
|
|
|
sub esc_html ($;%) {
|
replace invalid utf8 sequences by UTF-8 REPLACEMENT CHARACTER (efbfbd)
I still strongly disagree with the git maintainers not to hint people,
to use the only sane default encoding for a distributed project,
which is utf8. I'm tired of hearing filesystem development arguments.
Git is a software offered to merge forth and back across the world
and not to provide a content neutral filesystem.
Btw: I have nothing against the ability to run git in a closed environment,
with a different encoding, that's fine, sure. But that is obviously not
the case for the projects on kernel.org. It's about sane defaults,
nothing else.
You have to make decisions guy, as always in life. The problems to
allow random encoded garbage in commit messages _without_ storing
the encoding, just makes zero sense. Eighter you introduce a per-commit
encoding field, if you insist on this craziness, or you define a default
encoding. Everything else is just lazy and does not solve any problem,
besides that you can claim now, that you are not responsible for the mess
in the repository.
Gitweb shows several commits at once, you allow various encodings committed
to the same repository, without any hint what that garbage from the
individual commits is encoded with. No idea why you don't get
the problem - it's unsolvable. If you merge different peoples work, you
have to speak a common language!
Kay Sievers <kay.sievers@vrfy.org>
2005-11-19 16:41:29 +00:00
|
|
|
my $str = shift;
|
2006-11-01 13:33:21 +00:00
|
|
|
my %opts = @_;
|
|
|
|
|
2006-10-01 21:21:33 +00:00
|
|
|
$str = to_utf8($str);
|
2005-11-23 03:26:40 +00:00
|
|
|
$str = escapeHTML($str);
|
2006-11-01 13:33:21 +00:00
|
|
|
if ($opts{'-nbsp'}) {
|
|
|
|
$str =~ s/ / /g;
|
|
|
|
}
|
2006-11-08 23:11:10 +00:00
|
|
|
$str =~ s|([[:cntrl:]])|(($1 ne "\t") ? quot_cec($1) : $1)|eg;
|
replace invalid utf8 sequences by UTF-8 REPLACEMENT CHARACTER (efbfbd)
I still strongly disagree with the git maintainers not to hint people,
to use the only sane default encoding for a distributed project,
which is utf8. I'm tired of hearing filesystem development arguments.
Git is a software offered to merge forth and back across the world
and not to provide a content neutral filesystem.
Btw: I have nothing against the ability to run git in a closed environment,
with a different encoding, that's fine, sure. But that is obviously not
the case for the projects on kernel.org. It's about sane defaults,
nothing else.
You have to make decisions guy, as always in life. The problems to
allow random encoded garbage in commit messages _without_ storing
the encoding, just makes zero sense. Eighter you introduce a per-commit
encoding field, if you insist on this craziness, or you define a default
encoding. Everything else is just lazy and does not solve any problem,
besides that you can claim now, that you are not responsible for the mess
in the repository.
Gitweb shows several commits at once, you allow various encodings committed
to the same repository, without any hint what that garbage from the
individual commits is encoded with. No idea why you don't get
the problem - it's unsolvable. If you merge different peoples work, you
have to speak a common language!
Kay Sievers <kay.sievers@vrfy.org>
2005-11-19 16:41:29 +00:00
|
|
|
return $str;
|
|
|
|
}
|
|
|
|
|
2006-11-25 08:43:59 +00:00
|
|
|
# quote control characters and escape filename to HTML
|
|
|
|
sub esc_path {
|
|
|
|
my $str = shift;
|
|
|
|
my %opts = @_;
|
|
|
|
|
|
|
|
$str = to_utf8($str);
|
|
|
|
$str = escapeHTML($str);
|
|
|
|
if ($opts{'-nbsp'}) {
|
|
|
|
$str =~ s/ / /g;
|
|
|
|
}
|
|
|
|
$str =~ s|([[:cntrl:]])|quot_cec($1)|eg;
|
|
|
|
return $str;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Make control characters "printable", using character escape codes (CEC)
|
2006-11-08 10:50:07 +00:00
|
|
|
sub quot_cec {
|
|
|
|
my $cntrl = shift;
|
|
|
|
my %es = ( # character escape codes, aka escape sequences
|
|
|
|
"\t" => '\t', # tab (HT)
|
|
|
|
"\n" => '\n', # line feed (LF)
|
|
|
|
"\r" => '\r', # carrige return (CR)
|
|
|
|
"\f" => '\f', # form feed (FF)
|
|
|
|
"\b" => '\b', # backspace (BS)
|
|
|
|
"\a" => '\a', # alarm (bell) (BEL)
|
|
|
|
"\e" => '\e', # escape (ESC)
|
|
|
|
"\013" => '\v', # vertical tab (VT)
|
|
|
|
"\000" => '\0', # nul character (NUL)
|
|
|
|
);
|
|
|
|
my $chr = ( (exists $es{$cntrl})
|
|
|
|
? $es{$cntrl}
|
|
|
|
: sprintf('\%03o', ord($cntrl)) );
|
|
|
|
return "<span class=\"cntrl\">$chr</span>";
|
|
|
|
}
|
|
|
|
|
2006-11-25 08:43:59 +00:00
|
|
|
# Alternatively use unicode control pictures codepoints,
|
|
|
|
# Unicode "printable representation" (PR)
|
2006-11-08 10:50:07 +00:00
|
|
|
sub quot_upr {
|
|
|
|
my $cntrl = shift;
|
|
|
|
my $chr = sprintf('&#%04d;', 0x2400+ord($cntrl));
|
|
|
|
return "<span class=\"cntrl\">$chr</span>";
|
|
|
|
}
|
|
|
|
|
2005-11-24 15:56:55 +00:00
|
|
|
# git may return quoted and escaped filenames
|
|
|
|
sub unquote {
|
|
|
|
my $str = shift;
|
2006-11-08 10:48:56 +00:00
|
|
|
|
|
|
|
sub unq {
|
|
|
|
my $seq = shift;
|
|
|
|
my %es = ( # character escape codes, aka escape sequences
|
|
|
|
't' => "\t", # tab (HT, TAB)
|
|
|
|
'n' => "\n", # newline (NL)
|
|
|
|
'r' => "\r", # return (CR)
|
|
|
|
'f' => "\f", # form feed (FF)
|
|
|
|
'b' => "\b", # backspace (BS)
|
|
|
|
'a' => "\a", # alarm (bell) (BEL)
|
|
|
|
'e' => "\e", # escape (ESC)
|
|
|
|
'v' => "\013", # vertical tab (VT)
|
|
|
|
);
|
|
|
|
|
|
|
|
if ($seq =~ m/^[0-7]{1,3}$/) {
|
|
|
|
# octal char sequence
|
|
|
|
return chr(oct($seq));
|
|
|
|
} elsif (exists $es{$seq}) {
|
|
|
|
# C escape sequence, aka character escape code
|
|
|
|
return $es{$seq}
|
|
|
|
}
|
|
|
|
# quoted ordinary character
|
|
|
|
return $seq;
|
|
|
|
}
|
|
|
|
|
2005-11-24 15:56:55 +00:00
|
|
|
if ($str =~ m/^"(.*)"$/) {
|
2006-11-08 10:48:56 +00:00
|
|
|
# needs unquoting
|
2005-11-24 15:56:55 +00:00
|
|
|
$str = $1;
|
2006-11-08 10:48:56 +00:00
|
|
|
$str =~ s/\\([^0-7]|[0-7]{1,3})/unq($1)/eg;
|
2005-11-24 15:56:55 +00:00
|
|
|
}
|
|
|
|
return $str;
|
|
|
|
}
|
|
|
|
|
2006-08-06 00:08:31 +00:00
|
|
|
# escape tabs (convert tabs to spaces)
|
|
|
|
sub untabify {
|
|
|
|
my $line = shift;
|
|
|
|
|
|
|
|
while ((my $pos = index($line, "\t")) != -1) {
|
|
|
|
if (my $count = (8 - ($pos % 8))) {
|
|
|
|
my $spaces = ' ' x $count;
|
|
|
|
$line =~ s/\t/$spaces/;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $line;
|
|
|
|
}
|
|
|
|
|
2006-09-16 22:31:01 +00:00
|
|
|
sub project_in_list {
|
|
|
|
my $project = shift;
|
|
|
|
my @list = git_get_projects_list();
|
|
|
|
return @list && scalar(grep { $_->{'path'} eq $project } @list);
|
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ----------------------------------------------------------------------
|
|
|
|
## HTML aware string manipulation
|
|
|
|
|
|
|
|
sub chop_str {
|
|
|
|
my $str = shift;
|
|
|
|
my $len = shift;
|
|
|
|
my $add_len = shift || 10;
|
|
|
|
|
|
|
|
# allow only $len chars, but don't cut a word if it would fit in $add_len
|
|
|
|
# if it doesn't fit, cut it if it's still longer than the dots we would add
|
|
|
|
$str =~ m/^(.{0,$len}[^ \/\-_:\.@]{0,$add_len})(.*)/;
|
|
|
|
my $body = $1;
|
|
|
|
my $tail = $2;
|
|
|
|
if (length($tail) > 4) {
|
|
|
|
$tail = " ...";
|
|
|
|
$body =~ s/&[^;]*$//; # remove chopped character entities
|
|
|
|
}
|
|
|
|
return "$body$tail";
|
|
|
|
}
|
|
|
|
|
|
|
|
## ----------------------------------------------------------------------
|
|
|
|
## functions returning short strings
|
|
|
|
|
2006-06-20 14:58:12 +00:00
|
|
|
# CSS class for given age value (in seconds)
|
|
|
|
sub age_class {
|
|
|
|
my $age = shift;
|
|
|
|
|
|
|
|
if ($age < 60*60*2) {
|
|
|
|
return "age0";
|
|
|
|
} elsif ($age < 60*60*24*2) {
|
|
|
|
return "age1";
|
|
|
|
} else {
|
|
|
|
return "age2";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
# convert age in seconds to "nn units ago" string
|
|
|
|
sub age_string {
|
|
|
|
my $age = shift;
|
|
|
|
my $age_str;
|
2005-08-07 18:15:44 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
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";
|
2006-07-11 10:19:34 +00:00
|
|
|
} else {
|
2006-07-31 19:22:15 +00:00
|
|
|
$age_str .= " right now";
|
2005-08-07 17:52:52 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
return $age_str;
|
2005-08-07 17:49:46 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
# convert file mode in octal to symbolic file mode string
|
|
|
|
sub mode_str {
|
|
|
|
my $mode = oct shift;
|
|
|
|
|
|
|
|
if (S_ISDIR($mode & S_IFMT)) {
|
|
|
|
return 'drwxr-xr-x';
|
|
|
|
} elsif (S_ISLNK($mode)) {
|
|
|
|
return 'lrwxrwxrwx';
|
|
|
|
} elsif (S_ISREG($mode)) {
|
|
|
|
# git cares only about the executable bit
|
|
|
|
if ($mode & S_IXUSR) {
|
|
|
|
return '-rwxr-xr-x';
|
|
|
|
} else {
|
|
|
|
return '-rw-r--r--';
|
|
|
|
};
|
2005-08-07 18:27:18 +00:00
|
|
|
} else {
|
2006-07-31 19:22:15 +00:00
|
|
|
return '----------';
|
2005-08-07 18:13:02 +00:00
|
|
|
}
|
2005-08-07 17:49:46 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
# convert file mode in octal to file type string
|
|
|
|
sub file_type {
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
my $mode = shift;
|
|
|
|
|
|
|
|
if ($mode !~ m/^[0-7]+$/) {
|
|
|
|
return $mode;
|
|
|
|
} else {
|
|
|
|
$mode = oct $mode;
|
|
|
|
}
|
2005-08-07 18:17:19 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
if (S_ISDIR($mode & S_IFMT)) {
|
|
|
|
return "directory";
|
|
|
|
} elsif (S_ISLNK($mode)) {
|
|
|
|
return "symlink";
|
|
|
|
} elsif (S_ISREG($mode)) {
|
|
|
|
return "file";
|
|
|
|
} else {
|
|
|
|
return "unknown";
|
|
|
|
}
|
2005-08-07 18:15:44 +00:00
|
|
|
}
|
|
|
|
|
2006-11-08 16:59:41 +00:00
|
|
|
# convert file mode in octal to file type description string
|
|
|
|
sub file_type_long {
|
|
|
|
my $mode = shift;
|
|
|
|
|
|
|
|
if ($mode !~ m/^[0-7]+$/) {
|
|
|
|
return $mode;
|
|
|
|
} else {
|
|
|
|
$mode = oct $mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (S_ISDIR($mode & S_IFMT)) {
|
|
|
|
return "directory";
|
|
|
|
} elsif (S_ISLNK($mode)) {
|
|
|
|
return "symlink";
|
|
|
|
} elsif (S_ISREG($mode)) {
|
|
|
|
if ($mode & S_IXUSR) {
|
|
|
|
return "executable";
|
|
|
|
} else {
|
|
|
|
return "file";
|
|
|
|
};
|
|
|
|
} else {
|
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ----------------------------------------------------------------------
|
|
|
|
## functions returning short HTML fragments, or transforming HTML fragments
|
2007-02-04 04:49:16 +00:00
|
|
|
## which don't belong to other sections
|
2006-07-30 12:59:57 +00:00
|
|
|
|
2006-11-09 08:57:13 +00:00
|
|
|
# format line of commit message.
|
2006-07-31 19:22:15 +00:00
|
|
|
sub format_log_line_html {
|
|
|
|
my $line = shift;
|
2006-07-30 12:59:57 +00:00
|
|
|
|
2006-11-09 08:57:13 +00:00
|
|
|
$line = esc_html($line, -nbsp=>1);
|
gitweb: SHA-1 in commit log message links to "object" view
Instead of checking if explicit SHA-1 in commit log message is sha1 of
commit and making link to "commit" view, make [fragment of] explicit
SHA-1 in commit log message link to "object" view. While at it allow
to hyperlink also shortened SHA-1, from 8 characters up to full SHA-1,
instead of requiring full 40 characters of SHA-1.
This makes the following changes:
* SHA-1 of objects which no longer exists, for example in commit
cherry-picked from no longer existing temporary branch, or revert
of commit in rebased branch, are no longer marked as such by not
being made into hyperlink (and not having default hyperlink view:
being underlined among others). On the other hand it makes gitweb
to not write error messages when object is not found to web serwer
log; it also moves cost of getting type and SHA-1 validation to
when link is clicked, and not only viewed.
* SHA-1 of other objects: blobs, trees, tags are also hyperlinked
and lead to appropriate view (although in the case of tags it is
more natural to just use tag name).
* You can put shortened SHA-1 of commit in the commit message, and it
would be hyperlinked; it would be checked on clicking if abbrev is
unique.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-12-10 12:25:49 +00:00
|
|
|
if ($line =~ m/([0-9a-fA-F]{8,40})/) {
|
2006-07-31 19:22:15 +00:00
|
|
|
my $hash_text = $1;
|
gitweb: SHA-1 in commit log message links to "object" view
Instead of checking if explicit SHA-1 in commit log message is sha1 of
commit and making link to "commit" view, make [fragment of] explicit
SHA-1 in commit log message link to "object" view. While at it allow
to hyperlink also shortened SHA-1, from 8 characters up to full SHA-1,
instead of requiring full 40 characters of SHA-1.
This makes the following changes:
* SHA-1 of objects which no longer exists, for example in commit
cherry-picked from no longer existing temporary branch, or revert
of commit in rebased branch, are no longer marked as such by not
being made into hyperlink (and not having default hyperlink view:
being underlined among others). On the other hand it makes gitweb
to not write error messages when object is not found to web serwer
log; it also moves cost of getting type and SHA-1 validation to
when link is clicked, and not only viewed.
* SHA-1 of other objects: blobs, trees, tags are also hyperlinked
and lead to appropriate view (although in the case of tags it is
more natural to just use tag name).
* You can put shortened SHA-1 of commit in the commit message, and it
would be hyperlinked; it would be checked on clicking if abbrev is
unique.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-12-10 12:25:49 +00:00
|
|
|
my $link =
|
|
|
|
$cgi->a({-href => href(action=>"object", hash=>$hash_text),
|
|
|
|
-class => "text"}, $hash_text);
|
|
|
|
$line =~ s/$hash_text/$link/;
|
2006-07-30 12:59:57 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
return $line;
|
2006-07-30 12:59:57 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
# format marker of refs pointing to given object
|
2006-08-14 00:05:47 +00:00
|
|
|
sub format_ref_marker {
|
2006-07-31 19:22:15 +00:00
|
|
|
my ($refs, $id) = @_;
|
2006-08-14 00:14:20 +00:00
|
|
|
my $markers = '';
|
2006-07-30 18:32:01 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
if (defined $refs->{$id}) {
|
2006-08-14 00:14:20 +00:00
|
|
|
foreach my $ref (@{$refs->{$id}}) {
|
|
|
|
my ($type, $name) = qw();
|
|
|
|
# e.g. tags/v2.6.11 or heads/next
|
|
|
|
if ($ref =~ m!^(.*?)s?/(.*)$!) {
|
|
|
|
$type = $1;
|
|
|
|
$name = $2;
|
|
|
|
} else {
|
|
|
|
$type = "ref";
|
|
|
|
$name = $ref;
|
|
|
|
}
|
|
|
|
|
2006-12-15 22:49:12 +00:00
|
|
|
$markers .= " <span class=\"$type\" title=\"$ref\">" .
|
|
|
|
esc_html($name) . "</span>";
|
2006-08-14 00:14:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($markers) {
|
|
|
|
return ' <span class="refs">'. $markers . '</span>';
|
2006-07-31 19:22:15 +00:00
|
|
|
} else {
|
|
|
|
return "";
|
|
|
|
}
|
2006-07-30 18:32:01 +00:00
|
|
|
}
|
|
|
|
|
2006-08-14 00:08:27 +00:00
|
|
|
# format, perhaps shortened and with markers, title line
|
|
|
|
sub format_subject_html {
|
2006-08-15 22:24:30 +00:00
|
|
|
my ($long, $short, $href, $extra) = @_;
|
2006-08-14 00:08:27 +00:00
|
|
|
$extra = '' unless defined($extra);
|
|
|
|
|
|
|
|
if (length($short) < length($long)) {
|
2006-08-22 10:02:48 +00:00
|
|
|
return $cgi->a({-href => $href, -class => "list subject",
|
2006-10-01 21:21:33 +00:00
|
|
|
-title => to_utf8($long)},
|
2006-08-14 00:08:27 +00:00
|
|
|
esc_html($short) . $extra);
|
|
|
|
} else {
|
2006-08-22 10:02:48 +00:00
|
|
|
return $cgi->a({-href => $href, -class => "list subject"},
|
2006-08-14 00:08:27 +00:00
|
|
|
esc_html($long) . $extra);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-18 22:35:40 +00:00
|
|
|
# format patch (diff) line (rather not to be used for diff headers)
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
sub format_diff_line {
|
|
|
|
my $line = shift;
|
2006-11-18 22:35:40 +00:00
|
|
|
my ($from, $to) = @_;
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
my $char = substr($line, 0, 1);
|
|
|
|
my $diff_class = "";
|
|
|
|
|
|
|
|
chomp $line;
|
|
|
|
|
|
|
|
if ($char eq '+') {
|
|
|
|
$diff_class = " add";
|
|
|
|
} elsif ($char eq "-") {
|
|
|
|
$diff_class = " rem";
|
|
|
|
} elsif ($char eq "@") {
|
|
|
|
$diff_class = " chunk_header";
|
|
|
|
} elsif ($char eq "\\") {
|
2006-08-23 23:58:49 +00:00
|
|
|
$diff_class = " incomplete";
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
}
|
|
|
|
$line = untabify($line);
|
2006-11-18 22:35:40 +00:00
|
|
|
if ($from && $to && $line =~ m/^\@{2} /) {
|
|
|
|
my ($from_text, $from_start, $from_lines, $to_text, $to_start, $to_lines, $section) =
|
|
|
|
$line =~ m/^\@{2} (-(\d+)(?:,(\d+))?) (\+(\d+)(?:,(\d+))?) \@{2}(.*)$/;
|
|
|
|
|
|
|
|
$from_lines = 0 unless defined $from_lines;
|
|
|
|
$to_lines = 0 unless defined $to_lines;
|
|
|
|
|
|
|
|
if ($from->{'href'}) {
|
|
|
|
$from_text = $cgi->a({-href=>"$from->{'href'}#l$from_start",
|
|
|
|
-class=>"list"}, $from_text);
|
|
|
|
}
|
|
|
|
if ($to->{'href'}) {
|
|
|
|
$to_text = $cgi->a({-href=>"$to->{'href'}#l$to_start",
|
|
|
|
-class=>"list"}, $to_text);
|
|
|
|
}
|
|
|
|
$line = "<span class=\"chunk_info\">@@ $from_text $to_text @@</span>" .
|
|
|
|
"<span class=\"section\">" . esc_html($section, -nbsp=>1) . "</span>";
|
|
|
|
return "<div class=\"diff$diff_class\">$line</div>\n";
|
|
|
|
}
|
2006-11-01 13:33:21 +00:00
|
|
|
return "<div class=\"diff$diff_class\">" . esc_html($line, -nbsp=>1) . "</div>\n";
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ----------------------------------------------------------------------
|
|
|
|
## git utility subroutines, invoking git commands
|
2005-08-07 18:21:46 +00:00
|
|
|
|
2006-08-28 15:49:58 +00:00
|
|
|
# returns path to the core git executable and the --git-dir parameter as list
|
|
|
|
sub git_cmd {
|
|
|
|
return $GIT, '--git-dir='.$git_dir;
|
|
|
|
}
|
|
|
|
|
|
|
|
# returns path to the core git executable and the --git-dir parameter as string
|
|
|
|
sub git_cmd_str {
|
|
|
|
return join(' ', git_cmd());
|
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
# get HEAD ref of given project as hash
|
2006-08-14 00:05:47 +00:00
|
|
|
sub git_get_head_hash {
|
2006-01-09 12:13:39 +00:00
|
|
|
my $project = shift;
|
2006-08-28 15:49:58 +00:00
|
|
|
my $o_git_dir = $git_dir;
|
2006-01-09 12:13:39 +00:00
|
|
|
my $retval = undef;
|
2006-08-28 15:49:58 +00:00
|
|
|
$git_dir = "$projectroot/$project";
|
|
|
|
if (open my $fd, "-|", git_cmd(), "rev-parse", "--verify", "HEAD") {
|
2006-01-09 12:13:39 +00:00
|
|
|
my $head = <$fd>;
|
|
|
|
close $fd;
|
2006-01-17 02:50:20 +00:00
|
|
|
if (defined $head && $head =~ /^([0-9a-fA-F]{40})$/) {
|
|
|
|
$retval = $1;
|
2006-01-09 12:13:39 +00:00
|
|
|
}
|
|
|
|
}
|
2006-08-28 15:49:58 +00:00
|
|
|
if (defined $o_git_dir) {
|
|
|
|
$git_dir = $o_git_dir;
|
2006-01-17 02:50:20 +00:00
|
|
|
}
|
2006-01-09 12:13:39 +00:00
|
|
|
return $retval;
|
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
# get type of given object
|
|
|
|
sub git_get_type {
|
|
|
|
my $hash = shift;
|
|
|
|
|
2006-08-28 15:49:58 +00:00
|
|
|
open my $fd, "-|", git_cmd(), "cat-file", '-t', $hash or return;
|
2006-07-31 19:22:15 +00:00
|
|
|
my $type = <$fd>;
|
|
|
|
close $fd or return;
|
|
|
|
chomp $type;
|
|
|
|
return $type;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub git_get_project_config {
|
2006-08-20 06:23:04 +00:00
|
|
|
my ($key, $type) = @_;
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
return unless ($key);
|
|
|
|
$key =~ s/^gitweb\.//;
|
|
|
|
return if ($key =~ m/\W/);
|
|
|
|
|
2007-01-29 00:16:53 +00:00
|
|
|
my @x = (git_cmd(), 'config');
|
2006-08-20 06:23:04 +00:00
|
|
|
if (defined $type) { push @x, $type; }
|
|
|
|
push @x, "--get";
|
|
|
|
push @x, "gitweb.$key";
|
|
|
|
my $val = qx(@x);
|
|
|
|
chomp $val;
|
2006-07-31 19:22:15 +00:00
|
|
|
return ($val);
|
|
|
|
}
|
|
|
|
|
|
|
|
# get hash of given path at given ref
|
|
|
|
sub git_get_hash_by_path {
|
|
|
|
my $base = shift;
|
|
|
|
my $path = shift || return undef;
|
2006-09-21 16:09:12 +00:00
|
|
|
my $type = shift;
|
2006-07-31 19:22:15 +00:00
|
|
|
|
2006-09-25 23:54:24 +00:00
|
|
|
$path =~ s,/+$,,;
|
2006-07-31 19:22:15 +00:00
|
|
|
|
2006-08-28 15:49:58 +00:00
|
|
|
open my $fd, "-|", git_cmd(), "ls-tree", $base, "--", $path
|
2006-08-05 11:13:53 +00:00
|
|
|
or die_error(undef, "Open git-ls-tree failed");
|
2006-07-31 19:22:15 +00:00
|
|
|
my $line = <$fd>;
|
|
|
|
close $fd or return undef;
|
|
|
|
|
|
|
|
#'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
|
2006-10-30 21:25:11 +00:00
|
|
|
$line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/;
|
2006-09-21 16:09:12 +00:00
|
|
|
if (defined $type && $type ne $2) {
|
|
|
|
# type doesn't match
|
|
|
|
return undef;
|
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
return $3;
|
|
|
|
}
|
|
|
|
|
|
|
|
## ......................................................................
|
|
|
|
## git utility functions, directly accessing git repository
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
sub git_get_project_description {
|
2005-08-07 18:21:04 +00:00
|
|
|
my $path = shift;
|
2005-08-07 18:21:23 +00:00
|
|
|
|
2005-08-07 18:26:27 +00:00
|
|
|
open my $fd, "$projectroot/$path/description" or return undef;
|
2005-08-07 18:21:04 +00:00
|
|
|
my $descr = <$fd>;
|
|
|
|
close $fd;
|
|
|
|
chomp $descr;
|
|
|
|
return $descr;
|
2005-08-07 18:02:47 +00:00
|
|
|
}
|
|
|
|
|
2006-08-16 12:50:34 +00:00
|
|
|
sub git_get_project_url_list {
|
|
|
|
my $path = shift;
|
|
|
|
|
2006-09-22 23:15:18 +00:00
|
|
|
open my $fd, "$projectroot/$path/cloneurl" or return;
|
2006-08-16 12:50:34 +00:00
|
|
|
my @git_project_url_list = map { chomp; $_ } <$fd>;
|
|
|
|
close $fd;
|
|
|
|
|
|
|
|
return wantarray ? @git_project_url_list : \@git_project_url_list;
|
|
|
|
}
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
sub git_get_projects_list {
|
2006-10-24 03:33:17 +00:00
|
|
|
my ($filter) = @_;
|
2006-07-31 19:22:15 +00:00
|
|
|
my @list;
|
|
|
|
|
2006-10-24 03:33:17 +00:00
|
|
|
$filter ||= '';
|
|
|
|
$filter =~ s/\.git$//;
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
if (-d $projects_list) {
|
|
|
|
# search in directory
|
2006-10-24 03:33:17 +00:00
|
|
|
my $dir = $projects_list . ($filter ? "/$filter" : '');
|
2006-11-03 05:11:45 +00:00
|
|
|
# remove the trailing "/"
|
|
|
|
$dir =~ s!/+$!!;
|
2006-09-14 20:18:59 +00:00
|
|
|
my $pfxlen = length("$dir");
|
|
|
|
|
2006-11-08 06:00:45 +00:00
|
|
|
my ($check_forks) = gitweb_check_feature('forks');
|
2006-10-24 03:33:17 +00:00
|
|
|
|
2006-09-14 20:18:59 +00:00
|
|
|
File::Find::find({
|
|
|
|
follow_fast => 1, # follow symbolic links
|
|
|
|
dangling_symlinks => 0, # ignore dangling symlinks, silently
|
|
|
|
wanted => sub {
|
|
|
|
# skip project-list toplevel, if we get it.
|
|
|
|
return if (m!^[/.]$!);
|
|
|
|
# only directories can be git repositories
|
|
|
|
return unless (-d $_);
|
|
|
|
|
|
|
|
my $subdir = substr($File::Find::name, $pfxlen + 1);
|
|
|
|
# we check related file in $projectroot
|
2006-10-24 03:33:17 +00:00
|
|
|
if ($check_forks and $subdir =~ m#/.#) {
|
|
|
|
$File::Find::prune = 1;
|
|
|
|
} elsif (check_export_ok("$projectroot/$filter/$subdir")) {
|
|
|
|
push @list, { path => ($filter ? "$filter/" : '') . $subdir };
|
2006-09-14 20:18:59 +00:00
|
|
|
$File::Find::prune = 1;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
}, "$dir");
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
} elsif (-f $projects_list) {
|
|
|
|
# read from file(url-encoded):
|
|
|
|
# 'git%2Fgit.git Linus+Torvalds'
|
|
|
|
# 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
|
|
|
|
# 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
|
2006-09-25 23:56:17 +00:00
|
|
|
open my ($fd), $projects_list or return;
|
2006-07-31 19:22:15 +00:00
|
|
|
while (my $line = <$fd>) {
|
|
|
|
chomp $line;
|
|
|
|
my ($path, $owner) = split ' ', $line;
|
|
|
|
$path = unescape($path);
|
|
|
|
$owner = unescape($owner);
|
|
|
|
if (!defined $path) {
|
|
|
|
next;
|
|
|
|
}
|
2006-11-08 06:37:17 +00:00
|
|
|
if ($filter ne '') {
|
|
|
|
# looking for forks;
|
|
|
|
my $pfx = substr($path, 0, length($filter));
|
|
|
|
if ($pfx ne $filter) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
my $sfx = substr($path, length($filter));
|
|
|
|
if ($sfx !~ /^\/.*\.git$/) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
}
|
2006-10-03 09:30:47 +00:00
|
|
|
if (check_export_ok("$projectroot/$path")) {
|
2006-07-31 19:22:15 +00:00
|
|
|
my $pr = {
|
|
|
|
path => $path,
|
2006-10-01 21:21:33 +00:00
|
|
|
owner => to_utf8($owner),
|
2006-07-31 19:22:15 +00:00
|
|
|
};
|
|
|
|
push @list, $pr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
close $fd;
|
|
|
|
}
|
|
|
|
@list = sort {$a->{'path'} cmp $b->{'path'}} @list;
|
|
|
|
return @list;
|
|
|
|
}
|
|
|
|
|
2006-08-14 00:10:06 +00:00
|
|
|
sub git_get_project_owner {
|
|
|
|
my $project = shift;
|
|
|
|
my $owner;
|
|
|
|
|
|
|
|
return undef unless $project;
|
|
|
|
|
|
|
|
# read from file (url-encoded):
|
|
|
|
# 'git%2Fgit.git Linus+Torvalds'
|
|
|
|
# 'libs%2Fklibc%2Fklibc.git H.+Peter+Anvin'
|
|
|
|
# 'linux%2Fhotplug%2Fudev.git Greg+Kroah-Hartman'
|
|
|
|
if (-f $projects_list) {
|
|
|
|
open (my $fd , $projects_list);
|
|
|
|
while (my $line = <$fd>) {
|
|
|
|
chomp $line;
|
|
|
|
my ($pr, $ow) = split ' ', $line;
|
|
|
|
$pr = unescape($pr);
|
|
|
|
$ow = unescape($ow);
|
|
|
|
if ($pr eq $project) {
|
2006-10-01 21:21:33 +00:00
|
|
|
$owner = to_utf8($ow);
|
2006-08-14 00:10:06 +00:00
|
|
|
last;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
close $fd;
|
|
|
|
}
|
|
|
|
if (!defined $owner) {
|
|
|
|
$owner = get_file_owner("$projectroot/$project");
|
|
|
|
}
|
|
|
|
|
|
|
|
return $owner;
|
|
|
|
}
|
|
|
|
|
2006-10-28 17:43:40 +00:00
|
|
|
sub git_get_last_activity {
|
|
|
|
my ($path) = @_;
|
|
|
|
my $fd;
|
|
|
|
|
|
|
|
$git_dir = "$projectroot/$path";
|
|
|
|
open($fd, "-|", git_cmd(), 'for-each-ref',
|
2006-12-22 19:38:13 +00:00
|
|
|
'--format=%(committer)',
|
2006-10-28 17:43:40 +00:00
|
|
|
'--sort=-committerdate',
|
2006-12-22 19:38:13 +00:00
|
|
|
'--count=1',
|
2006-10-28 17:43:40 +00:00
|
|
|
'refs/heads') or return;
|
|
|
|
my $most_recent = <$fd>;
|
|
|
|
close $fd or return;
|
|
|
|
if ($most_recent =~ / (\d+) [-+][01]\d\d\d$/) {
|
|
|
|
my $timestamp = $1;
|
|
|
|
my $age = time - $timestamp;
|
|
|
|
return ($age, age_string($age));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
sub git_get_references {
|
2006-07-31 19:22:15 +00:00
|
|
|
my $type = shift || "";
|
|
|
|
my %refs;
|
2006-11-25 10:32:08 +00:00
|
|
|
# 5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c refs/tags/v2.6.11
|
|
|
|
# c39ae07f393806ccf406ef966e9a15afc43cc36a refs/tags/v2.6.11^{}
|
|
|
|
open my $fd, "-|", git_cmd(), "show-ref", "--dereference",
|
|
|
|
($type ? ("--", "refs/$type") : ()) # use -- <pattern> if $type
|
2006-09-19 12:31:49 +00:00
|
|
|
or return;
|
2006-08-14 00:14:20 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
while (my $line = <$fd>) {
|
|
|
|
chomp $line;
|
2006-11-25 10:32:08 +00:00
|
|
|
if ($line =~ m!^([0-9a-fA-F]{40})\srefs/($type/?[^^]+)!) {
|
2006-07-31 19:22:15 +00:00
|
|
|
if (defined $refs{$1}) {
|
2006-08-14 00:14:20 +00:00
|
|
|
push @{$refs{$1}}, $2;
|
2006-07-31 19:22:15 +00:00
|
|
|
} else {
|
2006-08-14 00:14:20 +00:00
|
|
|
$refs{$1} = [ $2 ];
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
close $fd or return;
|
|
|
|
return \%refs;
|
|
|
|
}
|
|
|
|
|
2006-08-24 17:41:23 +00:00
|
|
|
sub git_get_rev_name_tags {
|
|
|
|
my $hash = shift || return undef;
|
|
|
|
|
2006-08-28 15:49:58 +00:00
|
|
|
open my $fd, "-|", git_cmd(), "name-rev", "--tags", $hash
|
2006-08-24 17:41:23 +00:00
|
|
|
or return;
|
|
|
|
my $name_rev = <$fd>;
|
|
|
|
close $fd;
|
|
|
|
|
|
|
|
if ($name_rev =~ m|^$hash tags/(.*)$|) {
|
|
|
|
return $1;
|
|
|
|
} else {
|
|
|
|
# catches also '$hash undefined' output
|
|
|
|
return undef;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ----------------------------------------------------------------------
|
|
|
|
## parse to hash functions
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
sub parse_date {
|
2006-07-31 19:22:15 +00:00
|
|
|
my $epoch = shift;
|
|
|
|
my $tz = shift || "-0000";
|
|
|
|
|
|
|
|
my %date;
|
|
|
|
my @months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
|
|
|
|
my @days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");
|
|
|
|
my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($epoch);
|
|
|
|
$date{'hour'} = $hour;
|
|
|
|
$date{'minute'} = $min;
|
|
|
|
$date{'mday'} = $mday;
|
|
|
|
$date{'day'} = $days[$wday];
|
|
|
|
$date{'month'} = $months[$mon];
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
$date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
|
|
|
|
$days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
|
2006-08-22 14:52:50 +00:00
|
|
|
$date{'mday-time'} = sprintf "%d %s %02d:%02d",
|
|
|
|
$mday, $months[$mon], $hour ,$min;
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
$date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
|
|
|
|
1900+$year, $mon, $mday, $hour ,$min, $sec;
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
$tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
|
|
|
|
my $local = $epoch + ((int $1 + ($2/60)) * 3600);
|
|
|
|
($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($local);
|
|
|
|
$date{'hour_local'} = $hour;
|
|
|
|
$date{'minute_local'} = $min;
|
|
|
|
$date{'tz_local'} = $tz;
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
$date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
|
|
|
|
1900+$year, $mon+1, $mday,
|
|
|
|
$hour, $min, $sec, $tz);
|
2006-07-31 19:22:15 +00:00
|
|
|
return %date;
|
|
|
|
}
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
sub parse_tag {
|
2005-08-07 18:23:12 +00:00
|
|
|
my $tag_id = shift;
|
|
|
|
my %tag;
|
2005-08-07 18:28:53 +00:00
|
|
|
my @comment;
|
2005-08-07 18:23:12 +00:00
|
|
|
|
2006-08-28 15:49:58 +00:00
|
|
|
open my $fd, "-|", git_cmd(), "cat-file", "tag", $tag_id or return;
|
2005-08-07 18:28:53 +00:00
|
|
|
$tag{'id'} = $tag_id;
|
2005-08-07 18:23:12 +00:00
|
|
|
while (my $line = <$fd>) {
|
|
|
|
chomp $line;
|
|
|
|
if ($line =~ m/^object ([0-9a-fA-F]{40})$/) {
|
|
|
|
$tag{'object'} = $1;
|
2005-08-07 18:25:54 +00:00
|
|
|
} elsif ($line =~ m/^type (.+)$/) {
|
2005-08-07 18:23:12 +00:00
|
|
|
$tag{'type'} = $1;
|
2005-08-07 18:25:54 +00:00
|
|
|
} elsif ($line =~ m/^tag (.+)$/) {
|
2005-08-07 18:23:12 +00:00
|
|
|
$tag{'name'} = $1;
|
2005-08-07 18:28:53 +00:00
|
|
|
} elsif ($line =~ m/^tagger (.*) ([0-9]+) (.*)$/) {
|
|
|
|
$tag{'author'} = $1;
|
|
|
|
$tag{'epoch'} = $2;
|
|
|
|
$tag{'tz'} = $3;
|
|
|
|
} elsif ($line =~ m/--BEGIN/) {
|
|
|
|
push @comment, $line;
|
|
|
|
last;
|
|
|
|
} elsif ($line eq "") {
|
|
|
|
last;
|
2005-08-07 18:23:12 +00:00
|
|
|
}
|
|
|
|
}
|
2005-08-07 18:28:53 +00:00
|
|
|
push @comment, <$fd>;
|
|
|
|
$tag{'comment'} = \@comment;
|
2005-08-07 18:26:27 +00:00
|
|
|
close $fd or return;
|
2005-08-07 18:23:12 +00:00
|
|
|
if (!defined $tag{'name'}) {
|
|
|
|
return
|
|
|
|
};
|
|
|
|
return %tag
|
|
|
|
}
|
|
|
|
|
2006-12-24 14:31:42 +00:00
|
|
|
sub parse_commit_text {
|
2006-12-27 14:22:21 +00:00
|
|
|
my ($commit_text, $withparents) = @_;
|
2006-12-24 14:31:42 +00:00
|
|
|
my @commit_lines = split '\n', $commit_text;
|
2005-08-07 18:03:14 +00:00
|
|
|
my %co;
|
|
|
|
|
2006-12-24 14:31:42 +00:00
|
|
|
pop @commit_lines; # Remove '\0'
|
|
|
|
|
2005-09-13 00:21:59 +00:00
|
|
|
my $header = shift @commit_lines;
|
|
|
|
if (!($header =~ m/^[0-9a-fA-F]{40}/)) {
|
|
|
|
return;
|
|
|
|
}
|
2006-12-27 14:22:21 +00:00
|
|
|
($co{'id'}, my @parents) = split ' ', $header;
|
2005-08-07 18:26:27 +00:00
|
|
|
while (my $line = shift @commit_lines) {
|
2005-08-07 18:21:04 +00:00
|
|
|
last if $line eq "\n";
|
2005-08-07 18:25:54 +00:00
|
|
|
if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) {
|
2005-08-07 18:03:14 +00:00
|
|
|
$co{'tree'} = $1;
|
2006-12-27 14:22:21 +00:00
|
|
|
} elsif ((!defined $withparents) && ($line =~ m/^parent ([0-9a-fA-F]{40})$/)) {
|
2006-12-24 14:31:43 +00:00
|
|
|
push @parents, $1;
|
2005-08-07 18:06:09 +00:00
|
|
|
} elsif ($line =~ m/^author (.*) ([0-9]+) (.*)$/) {
|
2005-08-07 18:03:52 +00:00
|
|
|
$co{'author'} = $1;
|
2005-08-07 18:13:11 +00:00
|
|
|
$co{'author_epoch'} = $2;
|
|
|
|
$co{'author_tz'} = $3;
|
2006-11-25 14:54:32 +00:00
|
|
|
if ($co{'author'} =~ m/^([^<]+) <([^>]*)>/) {
|
|
|
|
$co{'author_name'} = $1;
|
|
|
|
$co{'author_email'} = $2;
|
2005-08-07 18:26:03 +00:00
|
|
|
} else {
|
|
|
|
$co{'author_name'} = $co{'author'};
|
|
|
|
}
|
2005-08-07 18:08:29 +00:00
|
|
|
} elsif ($line =~ m/^committer (.*) ([0-9]+) (.*)$/) {
|
|
|
|
$co{'committer'} = $1;
|
2005-08-07 18:13:11 +00:00
|
|
|
$co{'committer_epoch'} = $2;
|
|
|
|
$co{'committer_tz'} = $3;
|
2005-08-07 18:09:33 +00:00
|
|
|
$co{'committer_name'} = $co{'committer'};
|
2006-11-25 14:54:32 +00:00
|
|
|
if ($co{'committer'} =~ m/^([^<]+) <([^>]*)>/) {
|
|
|
|
$co{'committer_name'} = $1;
|
|
|
|
$co{'committer_email'} = $2;
|
|
|
|
} else {
|
|
|
|
$co{'committer_name'} = $co{'committer'};
|
|
|
|
}
|
2005-08-07 18:03:14 +00:00
|
|
|
}
|
|
|
|
}
|
2005-08-07 18:23:12 +00:00
|
|
|
if (!defined $co{'tree'}) {
|
2005-09-13 00:21:59 +00:00
|
|
|
return;
|
2005-08-07 18:23:12 +00:00
|
|
|
};
|
2006-12-24 14:31:43 +00:00
|
|
|
$co{'parents'} = \@parents;
|
|
|
|
$co{'parent'} = $parents[0];
|
2005-09-13 00:21:59 +00:00
|
|
|
|
2005-08-07 18:26:27 +00:00
|
|
|
foreach my $title (@commit_lines) {
|
2005-12-07 15:32:51 +00:00
|
|
|
$title =~ s/^ //;
|
2005-08-07 18:26:27 +00:00
|
|
|
if ($title ne "") {
|
2005-08-31 01:54:45 +00:00
|
|
|
$co{'title'} = chop_str($title, 80, 5);
|
2005-08-07 18:26:27 +00:00
|
|
|
# remove leading stuff of merges to make the interesting part visible
|
|
|
|
if (length($title) > 50) {
|
|
|
|
$title =~ s/^Automatic //;
|
|
|
|
$title =~ s/^merge (of|with) /Merge ... /i;
|
|
|
|
if (length($title) > 50) {
|
|
|
|
$title =~ s/(http|rsync):\/\///;
|
|
|
|
}
|
|
|
|
if (length($title) > 50) {
|
|
|
|
$title =~ s/(master|www|rsync)\.//;
|
|
|
|
}
|
|
|
|
if (length($title) > 50) {
|
|
|
|
$title =~ s/kernel.org:?//;
|
|
|
|
}
|
|
|
|
if (length($title) > 50) {
|
|
|
|
$title =~ s/\/pub\/scm//;
|
|
|
|
}
|
|
|
|
}
|
2005-08-31 01:54:45 +00:00
|
|
|
$co{'title_short'} = chop_str($title, 50, 5);
|
2005-08-07 18:26:27 +00:00
|
|
|
last;
|
|
|
|
}
|
|
|
|
}
|
2006-10-06 16:55:04 +00:00
|
|
|
if ($co{'title'} eq "") {
|
|
|
|
$co{'title'} = $co{'title_short'} = '(no commit message)';
|
|
|
|
}
|
2005-09-13 00:21:59 +00:00
|
|
|
# remove added spaces
|
|
|
|
foreach my $line (@commit_lines) {
|
|
|
|
$line =~ s/^ //;
|
|
|
|
}
|
|
|
|
$co{'comment'} = \@commit_lines;
|
2005-08-07 18:17:00 +00:00
|
|
|
|
|
|
|
my $age = time - $co{'committer_epoch'};
|
|
|
|
$co{'age'} = $age;
|
2005-08-07 18:29:03 +00:00
|
|
|
$co{'age_string'} = age_string($age);
|
2005-08-07 18:27:27 +00:00
|
|
|
my ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday) = gmtime($co{'committer_epoch'});
|
|
|
|
if ($age > 60*60*24*7*2) {
|
2005-08-07 18:28:01 +00:00
|
|
|
$co{'age_string_date'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
|
2005-08-07 18:27:27 +00:00
|
|
|
$co{'age_string_age'} = $co{'age_string'};
|
|
|
|
} else {
|
|
|
|
$co{'age_string_date'} = $co{'age_string'};
|
2005-08-07 18:28:01 +00:00
|
|
|
$co{'age_string_age'} = sprintf "%4i-%02u-%02i", 1900 + $year, $mon+1, $mday;
|
2005-08-07 18:27:27 +00:00
|
|
|
}
|
2005-08-07 18:03:14 +00:00
|
|
|
return %co;
|
|
|
|
}
|
|
|
|
|
2006-12-24 14:31:42 +00:00
|
|
|
sub parse_commit {
|
|
|
|
my ($commit_id) = @_;
|
|
|
|
my %co;
|
|
|
|
|
|
|
|
local $/ = "\0";
|
|
|
|
|
|
|
|
open my $fd, "-|", git_cmd(), "rev-list",
|
2006-12-27 14:22:21 +00:00
|
|
|
"--parents",
|
2006-12-24 14:31:42 +00:00
|
|
|
"--header",
|
|
|
|
"--max-count=1",
|
|
|
|
$commit_id,
|
|
|
|
"--",
|
|
|
|
or die_error(undef, "Open git-rev-list failed");
|
2006-12-27 14:22:21 +00:00
|
|
|
%co = parse_commit_text(<$fd>, 1);
|
2006-12-24 14:31:42 +00:00
|
|
|
close $fd;
|
|
|
|
|
|
|
|
return %co;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub parse_commits {
|
|
|
|
my ($commit_id, $maxcount, $skip, $arg, $filename) = @_;
|
|
|
|
my @cos;
|
|
|
|
|
|
|
|
$maxcount ||= 1;
|
|
|
|
$skip ||= 0;
|
|
|
|
|
|
|
|
local $/ = "\0";
|
|
|
|
|
|
|
|
open my $fd, "-|", git_cmd(), "rev-list",
|
|
|
|
"--header",
|
|
|
|
($arg ? ($arg) : ()),
|
|
|
|
("--max-count=" . $maxcount),
|
2006-12-24 14:31:49 +00:00
|
|
|
("--skip=" . $skip),
|
2006-12-24 14:31:42 +00:00
|
|
|
$commit_id,
|
|
|
|
"--",
|
|
|
|
($filename ? ($filename) : ())
|
|
|
|
or die_error(undef, "Open git-rev-list failed");
|
|
|
|
while (my $line = <$fd>) {
|
|
|
|
my %co = parse_commit_text($line);
|
|
|
|
push @cos, \%co;
|
|
|
|
}
|
|
|
|
close $fd;
|
|
|
|
|
|
|
|
return wantarray ? @cos : \@cos;
|
|
|
|
}
|
|
|
|
|
2006-08-14 00:07:00 +00:00
|
|
|
# parse ref from ref_file, given by ref_id, with given type
|
|
|
|
sub parse_ref {
|
|
|
|
my $ref_file = shift;
|
|
|
|
my $ref_id = shift;
|
|
|
|
my $type = shift || git_get_type($ref_id);
|
|
|
|
my %ref_item;
|
|
|
|
|
|
|
|
$ref_item{'type'} = $type;
|
|
|
|
$ref_item{'id'} = $ref_id;
|
|
|
|
$ref_item{'epoch'} = 0;
|
|
|
|
$ref_item{'age'} = "unknown";
|
|
|
|
if ($type eq "tag") {
|
|
|
|
my %tag = parse_tag($ref_id);
|
|
|
|
$ref_item{'comment'} = $tag{'comment'};
|
|
|
|
if ($tag{'type'} eq "commit") {
|
|
|
|
my %co = parse_commit($tag{'object'});
|
|
|
|
$ref_item{'epoch'} = $co{'committer_epoch'};
|
|
|
|
$ref_item{'age'} = $co{'age_string'};
|
|
|
|
} elsif (defined($tag{'epoch'})) {
|
|
|
|
my $age = time - $tag{'epoch'};
|
|
|
|
$ref_item{'epoch'} = $tag{'epoch'};
|
|
|
|
$ref_item{'age'} = age_string($age);
|
|
|
|
}
|
|
|
|
$ref_item{'reftype'} = $tag{'type'};
|
|
|
|
$ref_item{'name'} = $tag{'name'};
|
|
|
|
$ref_item{'refid'} = $tag{'object'};
|
|
|
|
} elsif ($type eq "commit"){
|
|
|
|
my %co = parse_commit($ref_id);
|
|
|
|
$ref_item{'reftype'} = "commit";
|
|
|
|
$ref_item{'name'} = $ref_file;
|
|
|
|
$ref_item{'title'} = $co{'title'};
|
|
|
|
$ref_item{'refid'} = $ref_id;
|
|
|
|
$ref_item{'epoch'} = $co{'committer_epoch'};
|
|
|
|
$ref_item{'age'} = $co{'age_string'};
|
|
|
|
} else {
|
|
|
|
$ref_item{'reftype'} = $type;
|
|
|
|
$ref_item{'name'} = $ref_file;
|
|
|
|
$ref_item{'refid'} = $ref_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
return %ref_item;
|
|
|
|
}
|
|
|
|
|
2006-08-21 21:08:52 +00:00
|
|
|
# parse line of git-diff-tree "raw" output
|
2006-08-21 21:07:00 +00:00
|
|
|
sub parse_difftree_raw_line {
|
|
|
|
my $line = shift;
|
|
|
|
my %res;
|
|
|
|
|
|
|
|
# ':100644 100644 03b218260e99b78c6df0ed378e59ed9205ccc96d 3b93d5e7cc7f7dd4ebed13a5cc1a4ad976fc94d8 M ls-files.c'
|
|
|
|
# ':100644 100644 7f9281985086971d3877aca27704f2aaf9c448ce bc190ebc71bbd923f2b728e505408f5e54bd073a M rev-tree.c'
|
|
|
|
if ($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/) {
|
|
|
|
$res{'from_mode'} = $1;
|
|
|
|
$res{'to_mode'} = $2;
|
|
|
|
$res{'from_id'} = $3;
|
|
|
|
$res{'to_id'} = $4;
|
|
|
|
$res{'status'} = $5;
|
|
|
|
$res{'similarity'} = $6;
|
|
|
|
if ($res{'status'} eq 'R' || $res{'status'} eq 'C') { # renamed or copied
|
2006-08-21 21:08:52 +00:00
|
|
|
($res{'from_file'}, $res{'to_file'}) = map { unquote($_) } split("\t", $7);
|
2006-08-21 21:07:00 +00:00
|
|
|
} else {
|
|
|
|
$res{'file'} = unquote($7);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
# 'c512b523472485aef4fff9e57b229d9d243c967f'
|
2006-08-30 22:36:04 +00:00
|
|
|
elsif ($line =~ m/^([0-9a-fA-F]{40})$/) {
|
|
|
|
$res{'commit'} = $1;
|
|
|
|
}
|
2006-08-21 21:07:00 +00:00
|
|
|
|
|
|
|
return wantarray ? %res : \%res;
|
|
|
|
}
|
|
|
|
|
2006-08-30 22:32:15 +00:00
|
|
|
# parse line of git-ls-tree output
|
|
|
|
sub parse_ls_tree_line ($;%) {
|
|
|
|
my $line = shift;
|
|
|
|
my %opts = @_;
|
|
|
|
my %res;
|
|
|
|
|
|
|
|
#'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
|
2006-10-30 21:25:11 +00:00
|
|
|
$line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t(.+)$/s;
|
2006-08-30 22:32:15 +00:00
|
|
|
|
|
|
|
$res{'mode'} = $1;
|
|
|
|
$res{'type'} = $2;
|
|
|
|
$res{'hash'} = $3;
|
|
|
|
if ($opts{'-z'}) {
|
|
|
|
$res{'name'} = $4;
|
|
|
|
} else {
|
|
|
|
$res{'name'} = unquote($4);
|
|
|
|
}
|
|
|
|
|
|
|
|
return wantarray ? %res : \%res;
|
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ......................................................................
|
|
|
|
## parse to array of hashes functions
|
2005-08-07 17:52:52 +00:00
|
|
|
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
sub git_get_heads_list {
|
|
|
|
my $limit = shift;
|
|
|
|
my @headslist;
|
|
|
|
|
|
|
|
open my $fd, '-|', git_cmd(), 'for-each-ref',
|
|
|
|
($limit ? '--count='.($limit+1) : ()), '--sort=-committerdate',
|
|
|
|
'--format=%(objectname) %(refname) %(subject)%00%(committer)',
|
|
|
|
'refs/heads'
|
2006-09-15 01:43:28 +00:00
|
|
|
or return;
|
|
|
|
while (my $line = <$fd>) {
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
my %ref_item;
|
2006-09-19 12:33:22 +00:00
|
|
|
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
chomp $line;
|
|
|
|
my ($refinfo, $committerinfo) = split(/\0/, $line);
|
|
|
|
my ($hash, $name, $title) = split(' ', $refinfo, 3);
|
|
|
|
my ($committer, $epoch, $tz) =
|
|
|
|
($committerinfo =~ /^(.*) ([0-9]+) (.*)$/);
|
|
|
|
$name =~ s!^refs/heads/!!;
|
|
|
|
|
|
|
|
$ref_item{'name'} = $name;
|
|
|
|
$ref_item{'id'} = $hash;
|
|
|
|
$ref_item{'title'} = $title || '(no commit message)';
|
|
|
|
$ref_item{'epoch'} = $epoch;
|
|
|
|
if ($epoch) {
|
|
|
|
$ref_item{'age'} = age_string(time - $ref_item{'epoch'});
|
|
|
|
} else {
|
|
|
|
$ref_item{'age'} = "unknown";
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
|
|
|
|
push @headslist, \%ref_item;
|
2006-09-15 01:43:28 +00:00
|
|
|
}
|
|
|
|
close $fd;
|
|
|
|
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
return wantarray ? @headslist : \@headslist;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub git_get_tags_list {
|
|
|
|
my $limit = shift;
|
|
|
|
my @tagslist;
|
|
|
|
|
|
|
|
open my $fd, '-|', git_cmd(), 'for-each-ref',
|
|
|
|
($limit ? '--count='.($limit+1) : ()), '--sort=-creatordate',
|
|
|
|
'--format=%(objectname) %(objecttype) %(refname) '.
|
|
|
|
'%(*objectname) %(*objecttype) %(subject)%00%(creator)',
|
|
|
|
'refs/tags'
|
|
|
|
or return;
|
|
|
|
while (my $line = <$fd>) {
|
|
|
|
my %ref_item;
|
2006-08-01 02:18:34 +00:00
|
|
|
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
chomp $line;
|
|
|
|
my ($refinfo, $creatorinfo) = split(/\0/, $line);
|
|
|
|
my ($id, $type, $name, $refid, $reftype, $title) = split(' ', $refinfo, 6);
|
|
|
|
my ($creator, $epoch, $tz) =
|
|
|
|
($creatorinfo =~ /^(.*) ([0-9]+) (.*)$/);
|
|
|
|
$name =~ s!^refs/tags/!!;
|
|
|
|
|
|
|
|
$ref_item{'type'} = $type;
|
|
|
|
$ref_item{'id'} = $id;
|
|
|
|
$ref_item{'name'} = $name;
|
|
|
|
if ($type eq "tag") {
|
|
|
|
$ref_item{'subject'} = $title;
|
|
|
|
$ref_item{'reftype'} = $reftype;
|
|
|
|
$ref_item{'refid'} = $refid;
|
|
|
|
} else {
|
|
|
|
$ref_item{'reftype'} = $type;
|
|
|
|
$ref_item{'refid'} = $id;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($type eq "tag" || $type eq "commit") {
|
|
|
|
$ref_item{'epoch'} = $epoch;
|
|
|
|
if ($epoch) {
|
|
|
|
$ref_item{'age'} = age_string(time - $ref_item{'epoch'});
|
|
|
|
} else {
|
|
|
|
$ref_item{'age'} = "unknown";
|
|
|
|
}
|
|
|
|
}
|
2005-08-07 18:09:33 +00:00
|
|
|
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
push @tagslist, \%ref_item;
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
close $fd;
|
|
|
|
|
|
|
|
return wantarray ? @tagslist : \@tagslist;
|
2005-08-07 18:08:29 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ----------------------------------------------------------------------
|
|
|
|
## filesystem-related functions
|
2005-08-07 18:06:09 +00:00
|
|
|
|
2005-08-07 18:22:44 +00:00
|
|
|
sub get_file_owner {
|
|
|
|
my $path = shift;
|
|
|
|
|
|
|
|
my ($dev, $ino, $mode, $nlink, $st_uid, $st_gid, $rdev, $size) = stat($path);
|
|
|
|
my ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpwuid($st_uid);
|
|
|
|
if (!defined $gcos) {
|
|
|
|
return undef;
|
|
|
|
}
|
|
|
|
my $owner = $gcos;
|
|
|
|
$owner =~ s/[,;].*$//;
|
2006-10-01 21:21:33 +00:00
|
|
|
return to_utf8($owner);
|
2005-08-07 18:22:44 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ......................................................................
|
|
|
|
## mimetype related functions
|
2005-08-07 18:21:23 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
sub mimetype_guess_file {
|
|
|
|
my $filename = shift;
|
|
|
|
my $mimemap = shift;
|
|
|
|
-r $mimemap or return undef;
|
|
|
|
|
|
|
|
my %mimemap;
|
|
|
|
open(MIME, $mimemap) or return undef;
|
|
|
|
while (<MIME>) {
|
2006-08-14 00:15:22 +00:00
|
|
|
next if m/^#/; # skip comments
|
2006-07-31 19:22:15 +00:00
|
|
|
my ($mime, $exts) = split(/\t+/);
|
2006-08-01 02:24:37 +00:00
|
|
|
if (defined $exts) {
|
|
|
|
my @exts = split(/\s+/, $exts);
|
|
|
|
foreach my $ext (@exts) {
|
|
|
|
$mimemap{$ext} = $mime;
|
|
|
|
}
|
2005-08-07 18:21:23 +00:00
|
|
|
}
|
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
close(MIME);
|
2005-08-07 18:21:23 +00:00
|
|
|
|
2006-09-19 11:57:03 +00:00
|
|
|
$filename =~ /\.([^.]*)$/;
|
2006-07-31 19:22:15 +00:00
|
|
|
return $mimemap{$1};
|
|
|
|
}
|
2006-06-12 08:31:57 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
sub mimetype_guess {
|
|
|
|
my $filename = shift;
|
|
|
|
my $mime;
|
|
|
|
$filename =~ /\./ or return undef;
|
2006-06-12 08:31:57 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
if ($mimetypes_file) {
|
|
|
|
my $file = $mimetypes_file;
|
2006-08-14 00:16:33 +00:00
|
|
|
if ($file !~ m!^/!) { # if it is relative path
|
|
|
|
# it is relative to project
|
|
|
|
$file = "$projectroot/$project/$file";
|
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
$mime = mimetype_guess_file($filename, $file);
|
|
|
|
}
|
|
|
|
$mime ||= mimetype_guess_file($filename, '/etc/mime.types');
|
|
|
|
return $mime;
|
2006-06-12 08:31:57 +00:00
|
|
|
}
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
sub blob_mimetype {
|
2006-07-31 19:22:15 +00:00
|
|
|
my $fd = shift;
|
|
|
|
my $filename = shift;
|
2006-06-12 08:31:57 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
if ($filename) {
|
|
|
|
my $mime = mimetype_guess($filename);
|
|
|
|
$mime and return $mime;
|
2005-08-12 19:43:32 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
# just in case
|
|
|
|
return $default_blob_plain_mimetype unless $fd;
|
|
|
|
|
|
|
|
if (-T $fd) {
|
|
|
|
return 'text/plain' .
|
|
|
|
($default_text_plain_charset ? '; charset='.$default_text_plain_charset : '');
|
|
|
|
} elsif (! $filename) {
|
|
|
|
return 'application/octet-stream';
|
|
|
|
} elsif ($filename =~ m/\.png$/i) {
|
|
|
|
return 'image/png';
|
|
|
|
} elsif ($filename =~ m/\.gif$/i) {
|
|
|
|
return 'image/gif';
|
|
|
|
} elsif ($filename =~ m/\.jpe?g$/i) {
|
|
|
|
return 'image/jpeg';
|
2005-08-12 19:43:32 +00:00
|
|
|
} else {
|
2006-07-31 19:22:15 +00:00
|
|
|
return 'application/octet-stream';
|
2005-08-10 01:53:09 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
## ======================================================================
|
|
|
|
## functions printing HTML: header, footer, error page
|
|
|
|
|
|
|
|
sub git_header_html {
|
|
|
|
my $status = shift || "200 OK";
|
|
|
|
my $expires = shift;
|
|
|
|
|
2006-10-24 03:18:39 +00:00
|
|
|
my $title = "$site_name";
|
2006-07-31 19:22:15 +00:00
|
|
|
if (defined $project) {
|
2007-01-30 10:23:38 +00:00
|
|
|
$title .= " - " . to_utf8($project);
|
2006-07-31 19:22:15 +00:00
|
|
|
if (defined $action) {
|
|
|
|
$title .= "/$action";
|
|
|
|
if (defined $file_name) {
|
2006-11-08 10:48:56 +00:00
|
|
|
$title .= " - " . esc_path($file_name);
|
2006-07-31 19:22:15 +00:00
|
|
|
if ($action eq "tree" && $file_name !~ m|/$|) {
|
|
|
|
$title .= "/";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-08-10 01:53:09 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
my $content_type;
|
|
|
|
# require explicit support from the UA if we are to send the page as
|
|
|
|
# 'application/xhtml+xml', otherwise send it as plain old 'text/html'.
|
|
|
|
# we have to do this because MSIE sometimes globs '*/*', pretending to
|
|
|
|
# support xhtml+xml but choking when it gets what it asked for.
|
2006-08-22 14:52:50 +00:00
|
|
|
if (defined $cgi->http('HTTP_ACCEPT') &&
|
|
|
|
$cgi->http('HTTP_ACCEPT') =~ m/(,|;|\s|^)application\/xhtml\+xml(,|;|\s|$)/ &&
|
|
|
|
$cgi->Accept('application/xhtml+xml') != 0) {
|
2006-07-31 19:22:15 +00:00
|
|
|
$content_type = 'application/xhtml+xml';
|
2005-08-10 01:53:09 +00:00
|
|
|
} else {
|
2006-07-31 19:22:15 +00:00
|
|
|
$content_type = 'text/html';
|
2005-08-10 01:53:09 +00:00
|
|
|
}
|
2006-08-22 14:52:50 +00:00
|
|
|
print $cgi->header(-type=>$content_type, -charset => 'utf-8',
|
|
|
|
-status=> $status, -expires => $expires);
|
2006-12-27 22:59:51 +00:00
|
|
|
my $mod_perl_version = $ENV{'MOD_PERL'} ? " $ENV{'MOD_PERL'}" : '';
|
2006-07-31 19:22:15 +00:00
|
|
|
print <<EOF;
|
|
|
|
<?xml version="1.0" encoding="utf-8"?>
|
|
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
|
|
|
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
|
2006-08-17 09:21:28 +00:00
|
|
|
<!-- git web interface version $version, (C) 2005-2006, Kay Sievers <kay.sievers\@vrfy.org>, Christian Gierke -->
|
2006-07-31 19:22:15 +00:00
|
|
|
<!-- git core binaries version $git_version -->
|
|
|
|
<head>
|
|
|
|
<meta http-equiv="content-type" content="$content_type; charset=utf-8"/>
|
2006-12-27 22:59:51 +00:00
|
|
|
<meta name="generator" content="gitweb/$version git/$git_version$mod_perl_version"/>
|
2006-07-31 19:22:15 +00:00
|
|
|
<meta name="robots" content="index, nofollow"/>
|
|
|
|
<title>$title</title>
|
|
|
|
EOF
|
2006-10-03 12:49:03 +00:00
|
|
|
# print out each stylesheet that exist
|
|
|
|
if (defined $stylesheet) {
|
|
|
|
#provides backwards capability for those people who define style sheet in a config file
|
|
|
|
print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
|
|
|
|
} else {
|
|
|
|
foreach my $stylesheet (@stylesheets) {
|
|
|
|
next unless $stylesheet;
|
|
|
|
print '<link rel="stylesheet" type="text/css" href="'.$stylesheet.'"/>'."\n";
|
|
|
|
}
|
|
|
|
}
|
2006-08-06 11:25:41 +00:00
|
|
|
if (defined $project) {
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
printf('<link rel="alternate" title="%s log RSS feed" '.
|
|
|
|
'href="%s" type="application/rss+xml" />'."\n",
|
2006-08-15 22:24:30 +00:00
|
|
|
esc_param($project), href(action=>"rss"));
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
printf('<link rel="alternate" title="%s log Atom feed" '.
|
|
|
|
'href="%s" type="application/atom+xml" />'."\n",
|
|
|
|
esc_param($project), href(action=>"atom"));
|
2006-09-15 09:11:33 +00:00
|
|
|
} else {
|
|
|
|
printf('<link rel="alternate" title="%s projects list" '.
|
|
|
|
'href="%s" type="text/plain; charset=utf-8"/>'."\n",
|
|
|
|
$site_name, href(project=>undef, action=>"project_index"));
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
printf('<link rel="alternate" title="%s projects feeds" '.
|
2006-09-15 09:11:33 +00:00
|
|
|
'href="%s" type="text/x-opml"/>'."\n",
|
|
|
|
$site_name, href(project=>undef, action=>"opml"));
|
2006-08-06 11:25:41 +00:00
|
|
|
}
|
2006-09-04 18:32:13 +00:00
|
|
|
if (defined $favicon) {
|
|
|
|
print qq(<link rel="shortcut icon" href="$favicon" type="image/png"/>\n);
|
|
|
|
}
|
2006-08-05 11:18:58 +00:00
|
|
|
|
2006-08-06 11:25:41 +00:00
|
|
|
print "</head>\n" .
|
2006-10-03 12:49:03 +00:00
|
|
|
"<body>\n";
|
|
|
|
|
|
|
|
if (-f $site_header) {
|
|
|
|
open (my $fd, $site_header);
|
|
|
|
print <$fd>;
|
|
|
|
close $fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
print "<div class=\"page_header\">\n" .
|
2006-10-06 10:31:05 +00:00
|
|
|
$cgi->a({-href => esc_url($logo_url),
|
|
|
|
-title => $logo_label},
|
|
|
|
qq(<img src="$logo" width="72" height="27" alt="git" class="logo"/>));
|
2006-09-25 23:58:41 +00:00
|
|
|
print $cgi->a({-href => esc_url($home_link)}, $home_link_str) . " / ";
|
2006-07-31 19:22:15 +00:00
|
|
|
if (defined $project) {
|
2006-08-15 22:24:30 +00:00
|
|
|
print $cgi->a({-href => href(action=>"summary")}, esc_html($project));
|
2006-07-31 19:22:15 +00:00
|
|
|
if (defined $action) {
|
|
|
|
print " / $action";
|
|
|
|
}
|
|
|
|
print "\n";
|
2006-12-23 03:35:16 +00:00
|
|
|
}
|
|
|
|
my ($have_search) = gitweb_check_feature('search');
|
|
|
|
if ((defined $project) && ($have_search)) {
|
2006-07-31 19:22:15 +00:00
|
|
|
if (!defined $searchtext) {
|
|
|
|
$searchtext = "";
|
|
|
|
}
|
|
|
|
my $search_hash;
|
|
|
|
if (defined $hash_base) {
|
|
|
|
$search_hash = $hash_base;
|
|
|
|
} elsif (defined $hash) {
|
|
|
|
$search_hash = $hash;
|
2005-08-07 18:25:42 +00:00
|
|
|
} else {
|
2006-07-31 19:22:15 +00:00
|
|
|
$search_hash = "HEAD";
|
2005-08-07 18:25:42 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
$cgi->param("a", "search");
|
|
|
|
$cgi->param("h", $search_hash);
|
2006-10-11 20:31:15 +00:00
|
|
|
$cgi->param("p", $project);
|
2006-07-31 19:22:15 +00:00
|
|
|
print $cgi->startform(-method => "get", -action => $my_uri) .
|
|
|
|
"<div class=\"search\">\n" .
|
|
|
|
$cgi->hidden(-name => "p") . "\n" .
|
|
|
|
$cgi->hidden(-name => "a") . "\n" .
|
|
|
|
$cgi->hidden(-name => "h") . "\n" .
|
2006-10-24 03:15:46 +00:00
|
|
|
$cgi->popup_menu(-name => 'st', -default => 'commit',
|
|
|
|
-values => ['commit', 'author', 'committer', 'pickaxe']) .
|
|
|
|
$cgi->sup($cgi->a({-href => href(action=>"search_help")}, "?")) .
|
|
|
|
" search:\n",
|
2006-07-31 19:22:15 +00:00
|
|
|
$cgi->textfield(-name => "s", -value => $searchtext) . "\n" .
|
|
|
|
"</div>" .
|
|
|
|
$cgi->end_form() . "\n";
|
2005-08-07 18:21:04 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
print "</div>\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
sub git_footer_html {
|
|
|
|
print "<div class=\"page_footer\">\n";
|
|
|
|
if (defined $project) {
|
2006-08-14 00:05:47 +00:00
|
|
|
my $descr = git_get_project_description($project);
|
2006-07-31 19:22:15 +00:00
|
|
|
if (defined $descr) {
|
|
|
|
print "<div class=\"page_footer_text\">" . esc_html($descr) . "</div>\n";
|
|
|
|
}
|
2006-09-15 17:30:34 +00:00
|
|
|
print $cgi->a({-href => href(action=>"rss"),
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
-class => "rss_logo"}, "RSS") . " ";
|
|
|
|
print $cgi->a({-href => href(action=>"atom"),
|
|
|
|
-class => "rss_logo"}, "Atom") . "\n";
|
2006-07-31 19:22:15 +00:00
|
|
|
} else {
|
2006-09-15 17:30:34 +00:00
|
|
|
print $cgi->a({-href => href(project=>undef, action=>"opml"),
|
2006-09-15 09:11:33 +00:00
|
|
|
-class => "rss_logo"}, "OPML") . " ";
|
|
|
|
print $cgi->a({-href => href(project=>undef, action=>"project_index"),
|
|
|
|
-class => "rss_logo"}, "TXT") . "\n";
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
2006-10-03 12:49:03 +00:00
|
|
|
print "</div>\n" ;
|
|
|
|
|
|
|
|
if (-f $site_footer) {
|
|
|
|
open (my $fd, $site_footer);
|
|
|
|
print <$fd>;
|
|
|
|
close $fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
print "</body>\n" .
|
2006-07-31 19:22:15 +00:00
|
|
|
"</html>";
|
|
|
|
}
|
|
|
|
|
|
|
|
sub die_error {
|
|
|
|
my $status = shift || "403 Forbidden";
|
|
|
|
my $error = shift || "Malformed query, file missing or permission denied";
|
|
|
|
|
|
|
|
git_header_html($status);
|
2006-08-22 21:42:53 +00:00
|
|
|
print <<EOF;
|
|
|
|
<div class="page_body">
|
|
|
|
<br /><br />
|
|
|
|
$status - $error
|
|
|
|
<br />
|
|
|
|
</div>
|
|
|
|
EOF
|
2005-08-07 18:21:04 +00:00
|
|
|
git_footer_html();
|
2006-07-31 19:22:15 +00:00
|
|
|
exit;
|
2005-08-07 17:49:46 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ----------------------------------------------------------------------
|
|
|
|
## functions printing or outputting HTML: navigation
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
sub git_print_page_nav {
|
2006-07-31 19:22:15 +00:00
|
|
|
my ($current, $suppress, $head, $treehead, $treebase, $extra) = @_;
|
|
|
|
$extra = '' if !defined $extra; # pager or formats
|
|
|
|
|
|
|
|
my @navs = qw(summary shortlog log commit commitdiff tree);
|
|
|
|
if ($suppress) {
|
|
|
|
@navs = grep { $_ ne $suppress } @navs;
|
|
|
|
}
|
|
|
|
|
2006-08-15 22:24:30 +00:00
|
|
|
my %arg = map { $_ => {action=>$_} } @navs;
|
2006-07-31 19:22:15 +00:00
|
|
|
if (defined $head) {
|
|
|
|
for (qw(commit commitdiff)) {
|
2006-08-15 22:24:30 +00:00
|
|
|
$arg{$_}{hash} = $head;
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
|
|
|
if ($current =~ m/^(tree | log | shortlog | commit | commitdiff | search)$/x) {
|
|
|
|
for (qw(shortlog log)) {
|
2006-08-15 22:24:30 +00:00
|
|
|
$arg{$_}{hash} = $head;
|
2005-12-07 09:12:55 +00:00
|
|
|
}
|
2005-12-07 08:44:06 +00:00
|
|
|
}
|
|
|
|
}
|
2006-08-15 22:24:30 +00:00
|
|
|
$arg{tree}{hash} = $treehead if defined $treehead;
|
|
|
|
$arg{tree}{hash_base} = $treebase if defined $treebase;
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
print "<div class=\"page_nav\">\n" .
|
|
|
|
(join " | ",
|
2006-08-15 22:24:30 +00:00
|
|
|
map { $_ eq $current ?
|
|
|
|
$_ : $cgi->a({-href => href(%{$arg{$_}})}, "$_")
|
|
|
|
} @navs);
|
2006-07-31 19:22:15 +00:00
|
|
|
print "<br/>\n$extra<br/>\n" .
|
|
|
|
"</div>\n";
|
2005-12-07 08:44:06 +00:00
|
|
|
}
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
sub format_paging_nav {
|
2006-07-31 19:22:15 +00:00
|
|
|
my ($action, $hash, $head, $page, $nrevs) = @_;
|
|
|
|
my $paging_nav;
|
2006-07-31 00:21:52 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
if ($hash ne $head || $page) {
|
2006-08-15 22:24:30 +00:00
|
|
|
$paging_nav .= $cgi->a({-href => href(action=>$action)}, "HEAD");
|
2006-07-31 00:21:52 +00:00
|
|
|
} else {
|
2006-07-31 19:22:15 +00:00
|
|
|
$paging_nav .= "HEAD";
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($page > 0) {
|
|
|
|
$paging_nav .= " ⋅ " .
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(action=>$action, hash=>$hash, page=>$page-1),
|
2006-08-10 10:38:47 +00:00
|
|
|
-accesskey => "p", -title => "Alt-p"}, "prev");
|
2006-07-31 19:22:15 +00:00
|
|
|
} else {
|
|
|
|
$paging_nav .= " ⋅ prev";
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($nrevs >= (100 * ($page+1)-1)) {
|
|
|
|
$paging_nav .= " ⋅ " .
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(action=>$action, hash=>$hash, page=>$page+1),
|
2006-08-10 10:38:47 +00:00
|
|
|
-accesskey => "n", -title => "Alt-n"}, "next");
|
2006-07-31 19:22:15 +00:00
|
|
|
} else {
|
|
|
|
$paging_nav .= " ⋅ next";
|
2006-07-31 00:21:52 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
return $paging_nav;
|
2006-07-31 00:21:52 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ......................................................................
|
|
|
|
## functions printing or outputting HTML: div
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
sub git_print_header_div {
|
2006-07-31 19:22:15 +00:00
|
|
|
my ($action, $title, $hash, $hash_base) = @_;
|
2006-08-15 22:24:30 +00:00
|
|
|
my %args = ();
|
2006-07-31 19:22:15 +00:00
|
|
|
|
2006-08-15 22:24:30 +00:00
|
|
|
$args{action} = $action;
|
|
|
|
$args{hash} = $hash if $hash;
|
|
|
|
$args{hash_base} = $hash_base if $hash_base;
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
print "<div class=\"header\">\n" .
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(%args), -class => "title"},
|
|
|
|
$title ? $title : $action) .
|
|
|
|
"\n</div>\n";
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
2005-08-07 18:23:12 +00:00
|
|
|
|
2006-08-28 12:48:12 +00:00
|
|
|
#sub git_print_authorship (\%) {
|
|
|
|
sub git_print_authorship {
|
|
|
|
my $co = shift;
|
|
|
|
|
2006-08-28 21:17:31 +00:00
|
|
|
my %ad = parse_date($co->{'author_epoch'}, $co->{'author_tz'});
|
2006-08-28 12:48:12 +00:00
|
|
|
print "<div class=\"author_date\">" .
|
|
|
|
esc_html($co->{'author_name'}) .
|
2006-08-28 21:17:31 +00:00
|
|
|
" [$ad{'rfc2822'}";
|
|
|
|
if ($ad{'hour_local'} < 6) {
|
|
|
|
printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
|
|
|
|
$ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
|
|
|
|
} else {
|
|
|
|
printf(" (%02d:%02d %s)",
|
|
|
|
$ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
|
|
|
|
}
|
|
|
|
print "]</div>\n";
|
2006-08-28 12:48:12 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
sub git_print_page_path {
|
|
|
|
my $name = shift;
|
|
|
|
my $type = shift;
|
2006-08-17 17:39:29 +00:00
|
|
|
my $hb = shift;
|
2005-08-07 18:23:12 +00:00
|
|
|
|
2006-10-21 15:53:55 +00:00
|
|
|
|
|
|
|
print "<div class=\"page_path\">";
|
|
|
|
print $cgi->a({-href => href(action=>"tree", hash_base=>$hb),
|
2007-02-06 09:09:32 +00:00
|
|
|
-title => 'tree root'}, to_utf8("[$project]"));
|
2006-10-21 15:53:55 +00:00
|
|
|
print " / ";
|
|
|
|
if (defined $name) {
|
2006-09-04 16:17:58 +00:00
|
|
|
my @dirname = split '/', $name;
|
|
|
|
my $basename = pop @dirname;
|
|
|
|
my $fullname = '';
|
|
|
|
|
|
|
|
foreach my $dir (@dirname) {
|
2006-09-21 00:05:50 +00:00
|
|
|
$fullname .= ($fullname ? '/' : '') . $dir;
|
2006-09-04 16:17:58 +00:00
|
|
|
print $cgi->a({-href => href(action=>"tree", file_name=>$fullname,
|
|
|
|
hash_base=>$hb),
|
2006-11-08 23:11:10 +00:00
|
|
|
-title => esc_html($fullname)}, esc_path($dir));
|
2006-09-22 23:00:12 +00:00
|
|
|
print " / ";
|
2006-09-04 16:17:58 +00:00
|
|
|
}
|
|
|
|
if (defined $type && $type eq 'blob') {
|
2006-08-22 14:52:50 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blob_plain", file_name=>$file_name,
|
2006-09-04 16:17:58 +00:00
|
|
|
hash_base=>$hb),
|
2006-11-08 23:11:10 +00:00
|
|
|
-title => esc_html($name)}, esc_path($basename));
|
2006-09-04 16:17:58 +00:00
|
|
|
} elsif (defined $type && $type eq 'tree') {
|
|
|
|
print $cgi->a({-href => href(action=>"tree", file_name=>$file_name,
|
|
|
|
hash_base=>$hb),
|
2006-11-08 23:11:10 +00:00
|
|
|
-title => esc_html($name)}, esc_path($basename));
|
2006-10-21 15:53:55 +00:00
|
|
|
print " / ";
|
2006-08-17 17:39:29 +00:00
|
|
|
} else {
|
2006-11-08 10:48:56 +00:00
|
|
|
print esc_path($basename);
|
2006-08-17 17:39:29 +00:00
|
|
|
}
|
2005-08-07 18:23:12 +00:00
|
|
|
}
|
2006-10-21 15:53:55 +00:00
|
|
|
print "<br/></div>\n";
|
2005-08-07 18:23:12 +00:00
|
|
|
}
|
|
|
|
|
2006-08-28 12:48:10 +00:00
|
|
|
# sub git_print_log (\@;%) {
|
|
|
|
sub git_print_log ($;%) {
|
2006-08-17 09:21:23 +00:00
|
|
|
my $log = shift;
|
2006-08-28 12:48:10 +00:00
|
|
|
my %opts = @_;
|
2006-08-17 09:21:23 +00:00
|
|
|
|
2006-08-28 12:48:10 +00:00
|
|
|
if ($opts{'-remove_title'}) {
|
|
|
|
# remove title, i.e. first line of log
|
|
|
|
shift @$log;
|
|
|
|
}
|
2006-08-17 09:21:23 +00:00
|
|
|
# remove leading empty lines
|
|
|
|
while (defined $log->[0] && $log->[0] eq "") {
|
|
|
|
shift @$log;
|
|
|
|
}
|
|
|
|
|
|
|
|
# print log
|
|
|
|
my $signoff = 0;
|
|
|
|
my $empty = 0;
|
|
|
|
foreach my $line (@$log) {
|
2006-08-28 12:48:10 +00:00
|
|
|
if ($line =~ m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i) {
|
|
|
|
$signoff = 1;
|
2006-08-28 12:48:13 +00:00
|
|
|
$empty = 0;
|
2006-08-28 12:48:10 +00:00
|
|
|
if (! $opts{'-remove_signoff'}) {
|
|
|
|
print "<span class=\"signoff\">" . esc_html($line) . "</span><br/>\n";
|
|
|
|
next;
|
|
|
|
} else {
|
|
|
|
# remove signoff lines
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$signoff = 0;
|
|
|
|
}
|
|
|
|
|
2006-08-17 09:21:23 +00:00
|
|
|
# print only one empty line
|
|
|
|
# do not print empty line after signoff
|
|
|
|
if ($line eq "") {
|
|
|
|
next if ($empty || $signoff);
|
|
|
|
$empty = 1;
|
|
|
|
} else {
|
|
|
|
$empty = 0;
|
|
|
|
}
|
2006-08-28 12:48:10 +00:00
|
|
|
|
|
|
|
print format_log_line_html($line) . "<br/>\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($opts{'-final_empty_line'}) {
|
|
|
|
# end with single empty line
|
|
|
|
print "<br/>\n" unless $empty;
|
2006-08-17 09:21:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-10 12:25:46 +00:00
|
|
|
# return link target (what link points to)
|
|
|
|
sub git_get_link_target {
|
|
|
|
my $hash = shift;
|
|
|
|
my $link_target;
|
|
|
|
|
|
|
|
# read link
|
|
|
|
open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
|
|
|
|
or return;
|
|
|
|
{
|
|
|
|
local $/;
|
|
|
|
$link_target = <$fd>;
|
|
|
|
}
|
|
|
|
close $fd
|
|
|
|
or return;
|
|
|
|
|
|
|
|
return $link_target;
|
|
|
|
}
|
|
|
|
|
2006-12-10 12:25:48 +00:00
|
|
|
# given link target, and the directory (basedir) the link is in,
|
|
|
|
# return target of link relative to top directory (top tree);
|
|
|
|
# return undef if it is not possible (including absolute links).
|
|
|
|
sub normalize_link_target {
|
|
|
|
my ($link_target, $basedir, $hash_base) = @_;
|
|
|
|
|
|
|
|
# we can normalize symlink target only if $hash_base is provided
|
|
|
|
return unless $hash_base;
|
|
|
|
|
|
|
|
# absolute symlinks (beginning with '/') cannot be normalized
|
|
|
|
return if (substr($link_target, 0, 1) eq '/');
|
|
|
|
|
|
|
|
# normalize link target to path from top (root) tree (dir)
|
|
|
|
my $path;
|
|
|
|
if ($basedir) {
|
|
|
|
$path = $basedir . '/' . $link_target;
|
|
|
|
} else {
|
|
|
|
# we are in top (root) tree (dir)
|
|
|
|
$path = $link_target;
|
|
|
|
}
|
|
|
|
|
|
|
|
# remove //, /./, and /../
|
|
|
|
my @path_parts;
|
|
|
|
foreach my $part (split('/', $path)) {
|
|
|
|
# discard '.' and ''
|
|
|
|
next if (!$part || $part eq '.');
|
|
|
|
# handle '..'
|
|
|
|
if ($part eq '..') {
|
|
|
|
if (@path_parts) {
|
|
|
|
pop @path_parts;
|
|
|
|
} else {
|
|
|
|
# link leads outside repository (outside top dir)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
push @path_parts, $part;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$path = join('/', @path_parts);
|
|
|
|
|
|
|
|
return $path;
|
|
|
|
}
|
2006-12-10 12:25:46 +00:00
|
|
|
|
2006-08-30 22:35:07 +00:00
|
|
|
# print tree entry (row of git_tree), but without encompassing <tr> element
|
|
|
|
sub git_print_tree_entry {
|
|
|
|
my ($t, $basedir, $hash_base, $have_blame) = @_;
|
|
|
|
|
|
|
|
my %base_key = ();
|
2006-12-10 12:25:46 +00:00
|
|
|
$base_key{'hash_base'} = $hash_base if defined $hash_base;
|
2006-08-30 22:35:07 +00:00
|
|
|
|
2006-09-26 05:38:16 +00:00
|
|
|
# The format of a table row is: mode list link. Where mode is
|
|
|
|
# the mode of the entry, list is the name of the entry, an href,
|
|
|
|
# and link is the action links of the entry.
|
|
|
|
|
2006-08-30 22:35:07 +00:00
|
|
|
print "<td class=\"mode\">" . mode_str($t->{'mode'}) . "</td>\n";
|
|
|
|
if ($t->{'type'} eq "blob") {
|
|
|
|
print "<td class=\"list\">" .
|
2006-09-26 05:38:16 +00:00
|
|
|
$cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
|
2006-10-21 15:52:19 +00:00
|
|
|
file_name=>"$basedir$t->{'name'}", %base_key),
|
2006-12-10 12:25:46 +00:00
|
|
|
-class => "list"}, esc_path($t->{'name'}));
|
|
|
|
if (S_ISLNK(oct $t->{'mode'})) {
|
|
|
|
my $link_target = git_get_link_target($t->{'hash'});
|
|
|
|
if ($link_target) {
|
2006-12-10 12:25:48 +00:00
|
|
|
my $norm_target = normalize_link_target($link_target, $basedir, $hash_base);
|
|
|
|
if (defined $norm_target) {
|
|
|
|
print " -> " .
|
|
|
|
$cgi->a({-href => href(action=>"object", hash_base=>$hash_base,
|
|
|
|
file_name=>$norm_target),
|
|
|
|
-title => $norm_target}, esc_path($link_target));
|
|
|
|
} else {
|
|
|
|
print " -> " . esc_path($link_target);
|
|
|
|
}
|
2006-12-10 12:25:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
print "</td>\n";
|
2006-09-26 05:38:16 +00:00
|
|
|
print "<td class=\"link\">";
|
2006-10-24 03:36:10 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blob", hash=>$t->{'hash'},
|
2006-12-10 12:25:46 +00:00
|
|
|
file_name=>"$basedir$t->{'name'}", %base_key)},
|
|
|
|
"blob");
|
2006-08-30 22:35:07 +00:00
|
|
|
if ($have_blame) {
|
2006-10-24 03:36:10 +00:00
|
|
|
print " | " .
|
|
|
|
$cgi->a({-href => href(action=>"blame", hash=>$t->{'hash'},
|
2006-12-10 12:25:46 +00:00
|
|
|
file_name=>"$basedir$t->{'name'}", %base_key)},
|
|
|
|
"blame");
|
2006-08-30 22:35:07 +00:00
|
|
|
}
|
|
|
|
if (defined $hash_base) {
|
2006-10-24 03:36:10 +00:00
|
|
|
print " | " .
|
|
|
|
$cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
|
2006-08-30 22:35:07 +00:00
|
|
|
hash=>$t->{'hash'}, file_name=>"$basedir$t->{'name'}")},
|
|
|
|
"history");
|
|
|
|
}
|
|
|
|
print " | " .
|
2006-09-29 16:57:43 +00:00
|
|
|
$cgi->a({-href => href(action=>"blob_plain", hash_base=>$hash_base,
|
2006-10-21 15:52:19 +00:00
|
|
|
file_name=>"$basedir$t->{'name'}")},
|
|
|
|
"raw");
|
2006-09-26 05:38:16 +00:00
|
|
|
print "</td>\n";
|
2006-08-30 22:35:07 +00:00
|
|
|
|
|
|
|
} elsif ($t->{'type'} eq "tree") {
|
2006-09-26 19:45:37 +00:00
|
|
|
print "<td class=\"list\">";
|
|
|
|
print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
|
2006-08-30 22:35:07 +00:00
|
|
|
file_name=>"$basedir$t->{'name'}", %base_key)},
|
2006-11-08 10:48:56 +00:00
|
|
|
esc_path($t->{'name'}));
|
2006-09-26 19:45:37 +00:00
|
|
|
print "</td>\n";
|
|
|
|
print "<td class=\"link\">";
|
2006-10-24 03:36:10 +00:00
|
|
|
print $cgi->a({-href => href(action=>"tree", hash=>$t->{'hash'},
|
2006-12-10 12:25:46 +00:00
|
|
|
file_name=>"$basedir$t->{'name'}", %base_key)},
|
|
|
|
"tree");
|
2006-08-30 22:35:07 +00:00
|
|
|
if (defined $hash_base) {
|
2006-10-24 03:36:10 +00:00
|
|
|
print " | " .
|
|
|
|
$cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
|
2006-08-30 22:35:07 +00:00
|
|
|
file_name=>"$basedir$t->{'name'}")},
|
|
|
|
"history");
|
|
|
|
}
|
|
|
|
print "</td>\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ......................................................................
|
|
|
|
## functions printing large fragments of HTML
|
|
|
|
|
2006-08-14 00:18:33 +00:00
|
|
|
sub git_difftree_body {
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
my ($difftree, $hash, $parent) = @_;
|
2006-11-08 20:22:04 +00:00
|
|
|
my ($have_blame) = gitweb_check_feature('blame');
|
2006-08-14 00:18:33 +00:00
|
|
|
print "<div class=\"list_head\">\n";
|
|
|
|
if ($#{$difftree} > 10) {
|
|
|
|
print(($#{$difftree} + 1) . " files changed:\n");
|
|
|
|
}
|
|
|
|
print "</div>\n";
|
|
|
|
|
|
|
|
print "<table class=\"diff_tree\">\n";
|
gitweb: "alternate" starts with shade (i.e. 1)
When displaying a list of rows (difftree, shortlog, etc),
the first entry is now printed shaded, i.e. alternate is
initialized to 1, as opposed to non-shaded (alternate
initialized to 0).
This solves the problem when there is only one row to
display -- it is displayed shaded to visually indicate that
it is "active", part of a "list", etc.
(Compare this to the trivial case of more than one entry,
where the rows have alternating shade, thus suggesting
being part of a "list" of "active" entries, etc.)
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-28 23:47:50 +00:00
|
|
|
my $alternate = 1;
|
2006-08-28 12:48:14 +00:00
|
|
|
my $patchno = 0;
|
2006-08-14 00:18:33 +00:00
|
|
|
foreach my $line (@{$difftree}) {
|
2006-08-21 21:08:52 +00:00
|
|
|
my %diff = parse_difftree_raw_line($line);
|
2006-08-14 00:18:33 +00:00
|
|
|
|
|
|
|
if ($alternate) {
|
|
|
|
print "<tr class=\"dark\">\n";
|
|
|
|
} else {
|
|
|
|
print "<tr class=\"light\">\n";
|
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
|
|
|
|
2006-08-21 21:08:52 +00:00
|
|
|
my ($to_mode_oct, $to_mode_str, $to_file_type);
|
|
|
|
my ($from_mode_oct, $from_mode_str, $from_file_type);
|
|
|
|
if ($diff{'to_mode'} ne ('0' x 6)) {
|
|
|
|
$to_mode_oct = oct $diff{'to_mode'};
|
|
|
|
if (S_ISREG($to_mode_oct)) { # only for regular file
|
|
|
|
$to_mode_str = sprintf("%04o", $to_mode_oct & 0777); # permission bits
|
|
|
|
}
|
|
|
|
$to_file_type = file_type($diff{'to_mode'});
|
|
|
|
}
|
|
|
|
if ($diff{'from_mode'} ne ('0' x 6)) {
|
|
|
|
$from_mode_oct = oct $diff{'from_mode'};
|
|
|
|
if (S_ISREG($to_mode_oct)) { # only for regular file
|
|
|
|
$from_mode_str = sprintf("%04o", $from_mode_oct & 0777); # permission bits
|
2006-08-14 00:18:33 +00:00
|
|
|
}
|
2006-08-21 21:08:52 +00:00
|
|
|
$from_file_type = file_type($diff{'from_mode'});
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($diff{'status'} eq "A") { # created
|
|
|
|
my $mode_chng = "<span class=\"file_status new\">[new $to_file_type";
|
|
|
|
$mode_chng .= " with mode: $to_mode_str" if $to_mode_str;
|
|
|
|
$mode_chng .= "]</span>";
|
2006-09-28 00:23:25 +00:00
|
|
|
print "<td>";
|
|
|
|
print $cgi->a({-href => href(action=>"blob", hash=>$diff{'to_id'},
|
2006-08-21 21:08:52 +00:00
|
|
|
hash_base=>$hash, file_name=>$diff{'file'}),
|
2006-11-08 10:48:56 +00:00
|
|
|
-class => "list"}, esc_path($diff{'file'}));
|
2006-09-28 00:23:25 +00:00
|
|
|
print "</td>\n";
|
|
|
|
print "<td>$mode_chng</td>\n";
|
|
|
|
print "<td class=\"link\">";
|
2006-09-04 16:19:58 +00:00
|
|
|
if ($action eq 'commitdiff') {
|
2006-08-28 12:48:14 +00:00
|
|
|
# link to patch
|
|
|
|
$patchno++;
|
2006-09-28 00:23:25 +00:00
|
|
|
print $cgi->a({-href => "#patch$patchno"}, "patch");
|
2006-11-19 21:51:39 +00:00
|
|
|
print " | ";
|
2006-08-28 12:48:14 +00:00
|
|
|
}
|
2006-11-19 21:51:39 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blob", hash=>$diff{'to_id'},
|
|
|
|
hash_base=>$hash, file_name=>$diff{'file'})},
|
2007-01-08 01:10:42 +00:00
|
|
|
"blob");
|
2006-08-28 12:48:14 +00:00
|
|
|
print "</td>\n";
|
2006-08-14 00:18:33 +00:00
|
|
|
|
2006-08-21 21:08:52 +00:00
|
|
|
} elsif ($diff{'status'} eq "D") { # deleted
|
|
|
|
my $mode_chng = "<span class=\"file_status deleted\">[deleted $from_file_type]</span>";
|
2006-09-28 00:23:25 +00:00
|
|
|
print "<td>";
|
|
|
|
print $cgi->a({-href => href(action=>"blob", hash=>$diff{'from_id'},
|
2006-08-21 21:08:52 +00:00
|
|
|
hash_base=>$parent, file_name=>$diff{'file'}),
|
2006-11-08 10:48:56 +00:00
|
|
|
-class => "list"}, esc_path($diff{'file'}));
|
2006-09-28 00:23:25 +00:00
|
|
|
print "</td>\n";
|
|
|
|
print "<td>$mode_chng</td>\n";
|
|
|
|
print "<td class=\"link\">";
|
2006-09-04 16:19:58 +00:00
|
|
|
if ($action eq 'commitdiff') {
|
2006-08-28 12:48:14 +00:00
|
|
|
# link to patch
|
|
|
|
$patchno++;
|
2006-09-28 00:23:25 +00:00
|
|
|
print $cgi->a({-href => "#patch$patchno"}, "patch");
|
|
|
|
print " | ";
|
2006-08-28 12:48:14 +00:00
|
|
|
}
|
2006-10-24 03:36:10 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blob", hash=>$diff{'from_id'},
|
|
|
|
hash_base=>$parent, file_name=>$diff{'file'})},
|
2006-11-19 21:51:39 +00:00
|
|
|
"blob") . " | ";
|
2006-11-08 20:22:04 +00:00
|
|
|
if ($have_blame) {
|
2006-11-19 21:51:39 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blame", hash_base=>$parent,
|
|
|
|
file_name=>$diff{'file'})},
|
|
|
|
"blame") . " | ";
|
2006-11-08 20:22:04 +00:00
|
|
|
}
|
2006-08-28 12:48:14 +00:00
|
|
|
print $cgi->a({-href => href(action=>"history", hash_base=>$parent,
|
2006-10-21 15:52:19 +00:00
|
|
|
file_name=>$diff{'file'})},
|
|
|
|
"history");
|
2006-09-28 00:23:25 +00:00
|
|
|
print "</td>\n";
|
2006-08-14 00:18:33 +00:00
|
|
|
|
2006-08-21 21:08:52 +00:00
|
|
|
} elsif ($diff{'status'} eq "M" || $diff{'status'} eq "T") { # modified, or type changed
|
2006-08-14 00:18:33 +00:00
|
|
|
my $mode_chnge = "";
|
2006-08-21 21:08:52 +00:00
|
|
|
if ($diff{'from_mode'} != $diff{'to_mode'}) {
|
|
|
|
$mode_chnge = "<span class=\"file_status mode_chnge\">[changed";
|
2007-01-03 19:47:24 +00:00
|
|
|
if ($from_file_type ne $to_file_type) {
|
2006-08-21 21:08:52 +00:00
|
|
|
$mode_chnge .= " from $from_file_type to $to_file_type";
|
2006-08-14 00:18:33 +00:00
|
|
|
}
|
2006-08-21 21:08:52 +00:00
|
|
|
if (($from_mode_oct & 0777) != ($to_mode_oct & 0777)) {
|
|
|
|
if ($from_mode_str && $to_mode_str) {
|
|
|
|
$mode_chnge .= " mode: $from_mode_str->$to_mode_str";
|
|
|
|
} elsif ($to_mode_str) {
|
|
|
|
$mode_chnge .= " mode: $to_mode_str";
|
2006-08-14 00:18:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
$mode_chnge .= "]</span>\n";
|
|
|
|
}
|
|
|
|
print "<td>";
|
2006-09-28 00:23:25 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blob", hash=>$diff{'to_id'},
|
2006-10-21 15:52:19 +00:00
|
|
|
hash_base=>$hash, file_name=>$diff{'file'}),
|
2006-11-08 10:48:56 +00:00
|
|
|
-class => "list"}, esc_path($diff{'file'}));
|
2006-09-28 00:23:25 +00:00
|
|
|
print "</td>\n";
|
|
|
|
print "<td>$mode_chnge</td>\n";
|
|
|
|
print "<td class=\"link\">";
|
2006-10-31 16:36:27 +00:00
|
|
|
if ($action eq 'commitdiff') {
|
|
|
|
# link to patch
|
|
|
|
$patchno++;
|
|
|
|
print $cgi->a({-href => "#patch$patchno"}, "patch") .
|
|
|
|
" | ";
|
|
|
|
} elsif ($diff{'to_id'} ne $diff{'from_id'}) {
|
|
|
|
# "commit" view and modified file (not onlu mode changed)
|
|
|
|
print $cgi->a({-href => href(action=>"blobdiff",
|
|
|
|
hash=>$diff{'to_id'}, hash_parent=>$diff{'from_id'},
|
|
|
|
hash_base=>$hash, hash_parent_base=>$parent,
|
|
|
|
file_name=>$diff{'file'})},
|
|
|
|
"diff") .
|
|
|
|
" | ";
|
2006-08-14 00:18:33 +00:00
|
|
|
}
|
2006-10-24 03:36:10 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blob", hash=>$diff{'to_id'},
|
2006-11-19 21:51:39 +00:00
|
|
|
hash_base=>$hash, file_name=>$diff{'file'})},
|
|
|
|
"blob") . " | ";
|
2006-11-08 20:22:04 +00:00
|
|
|
if ($have_blame) {
|
2006-11-19 21:51:39 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
|
|
|
|
file_name=>$diff{'file'})},
|
|
|
|
"blame") . " | ";
|
2006-11-08 20:22:04 +00:00
|
|
|
}
|
2006-09-28 00:24:49 +00:00
|
|
|
print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
|
2006-10-21 15:52:19 +00:00
|
|
|
file_name=>$diff{'file'})},
|
|
|
|
"history");
|
2006-08-14 00:18:33 +00:00
|
|
|
print "</td>\n";
|
|
|
|
|
2006-08-21 21:08:52 +00:00
|
|
|
} elsif ($diff{'status'} eq "R" || $diff{'status'} eq "C") { # renamed or copied
|
|
|
|
my %status_name = ('R' => 'moved', 'C' => 'copied');
|
|
|
|
my $nstatus = $status_name{$diff{'status'}};
|
2006-08-14 00:18:33 +00:00
|
|
|
my $mode_chng = "";
|
2006-08-21 21:08:52 +00:00
|
|
|
if ($diff{'from_mode'} != $diff{'to_mode'}) {
|
|
|
|
# mode also for directories, so we cannot use $to_mode_str
|
|
|
|
$mode_chng = sprintf(", mode: %04o", $to_mode_oct & 0777);
|
2006-08-14 00:18:33 +00:00
|
|
|
}
|
|
|
|
print "<td>" .
|
2006-08-21 21:08:52 +00:00
|
|
|
$cgi->a({-href => href(action=>"blob", hash_base=>$hash,
|
|
|
|
hash=>$diff{'to_id'}, file_name=>$diff{'to_file'}),
|
2006-11-08 10:48:56 +00:00
|
|
|
-class => "list"}, esc_path($diff{'to_file'})) . "</td>\n" .
|
2006-08-21 21:08:52 +00:00
|
|
|
"<td><span class=\"file_status $nstatus\">[$nstatus from " .
|
|
|
|
$cgi->a({-href => href(action=>"blob", hash_base=>$parent,
|
|
|
|
hash=>$diff{'from_id'}, file_name=>$diff{'from_file'}),
|
2006-11-08 10:48:56 +00:00
|
|
|
-class => "list"}, esc_path($diff{'from_file'})) .
|
2006-08-21 21:08:52 +00:00
|
|
|
" with " . (int $diff{'similarity'}) . "% similarity$mode_chng]</span></td>\n" .
|
2006-09-28 00:23:25 +00:00
|
|
|
"<td class=\"link\">";
|
2006-10-31 16:36:27 +00:00
|
|
|
if ($action eq 'commitdiff') {
|
|
|
|
# link to patch
|
|
|
|
$patchno++;
|
|
|
|
print $cgi->a({-href => "#patch$patchno"}, "patch") .
|
|
|
|
" | ";
|
|
|
|
} elsif ($diff{'to_id'} ne $diff{'from_id'}) {
|
|
|
|
# "commit" view and modified file (not only pure rename or copy)
|
|
|
|
print $cgi->a({-href => href(action=>"blobdiff",
|
|
|
|
hash=>$diff{'to_id'}, hash_parent=>$diff{'from_id'},
|
|
|
|
hash_base=>$hash, hash_parent_base=>$parent,
|
|
|
|
file_name=>$diff{'to_file'}, file_parent=>$diff{'from_file'})},
|
|
|
|
"diff") .
|
|
|
|
" | ";
|
2006-08-14 00:18:33 +00:00
|
|
|
}
|
2006-11-19 21:51:39 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blob", hash=>$diff{'to_id'},
|
|
|
|
hash_base=>$parent, file_name=>$diff{'to_file'})},
|
|
|
|
"blob") . " | ";
|
2006-11-08 20:22:04 +00:00
|
|
|
if ($have_blame) {
|
2006-11-19 21:51:39 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blame", hash_base=>$hash,
|
|
|
|
file_name=>$diff{'to_file'})},
|
|
|
|
"blame") . " | ";
|
2006-11-08 20:22:04 +00:00
|
|
|
}
|
2006-11-19 21:51:39 +00:00
|
|
|
print $cgi->a({-href => href(action=>"history", hash_base=>$hash,
|
|
|
|
file_name=>$diff{'to_file'})},
|
2006-10-21 15:52:19 +00:00
|
|
|
"history");
|
2006-08-14 00:18:33 +00:00
|
|
|
print "</td>\n";
|
2006-08-21 21:08:52 +00:00
|
|
|
|
2006-08-14 00:18:33 +00:00
|
|
|
} # we should not encounter Unmerged (U) or Unknown (X) status
|
|
|
|
print "</tr>\n";
|
|
|
|
}
|
|
|
|
print "</table>\n";
|
|
|
|
}
|
|
|
|
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
sub git_patchset_body {
|
2006-08-24 17:34:36 +00:00
|
|
|
my ($fd, $difftree, $hash, $hash_parent) = @_;
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
|
|
|
|
my $patch_idx = 0;
|
2006-11-18 22:35:39 +00:00
|
|
|
my $patch_line;
|
2006-08-25 18:59:39 +00:00
|
|
|
my $diffinfo;
|
2006-11-08 16:59:41 +00:00
|
|
|
my (%from, %to);
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
|
|
|
|
print "<div class=\"patchset\">\n";
|
|
|
|
|
2006-11-18 22:35:39 +00:00
|
|
|
# skip to first patch
|
|
|
|
while ($patch_line = <$fd>) {
|
2006-08-24 17:34:36 +00:00
|
|
|
chomp $patch_line;
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
|
2006-11-18 22:35:39 +00:00
|
|
|
last if ($patch_line =~ m/^diff /);
|
|
|
|
}
|
|
|
|
|
|
|
|
PATCH:
|
|
|
|
while ($patch_line) {
|
|
|
|
my @diff_header;
|
2007-01-07 01:52:23 +00:00
|
|
|
my ($from_id, $to_id);
|
2006-11-18 22:35:39 +00:00
|
|
|
|
|
|
|
# git diff header
|
|
|
|
#assert($patch_line =~ m/^diff /) if DEBUG;
|
|
|
|
#assert($patch_line !~ m!$/$!) if DEBUG; # is chomp-ed
|
|
|
|
push @diff_header, $patch_line;
|
|
|
|
|
|
|
|
# extended diff header
|
|
|
|
EXTENDED_HEADER:
|
|
|
|
while ($patch_line = <$fd>) {
|
|
|
|
chomp $patch_line;
|
|
|
|
|
2007-01-07 01:52:25 +00:00
|
|
|
last EXTENDED_HEADER if ($patch_line =~ m/^--- |^diff /);
|
2006-11-18 22:35:39 +00:00
|
|
|
|
|
|
|
if ($patch_line =~ m/^index ([0-9a-fA-F]{40})..([0-9a-fA-F]{40})/) {
|
|
|
|
$from_id = $1;
|
|
|
|
$to_id = $2;
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
}
|
2006-11-18 22:35:39 +00:00
|
|
|
|
|
|
|
push @diff_header, $patch_line;
|
|
|
|
}
|
|
|
|
my $last_patch_line = $patch_line;
|
|
|
|
|
|
|
|
# check if current patch belong to current raw line
|
|
|
|
# and parse raw git-diff line if needed
|
|
|
|
if (defined $diffinfo &&
|
|
|
|
$diffinfo->{'from_id'} eq $from_id &&
|
|
|
|
$diffinfo->{'to_id'} eq $to_id) {
|
|
|
|
# this is split patch
|
|
|
|
print "<div class=\"patch cont\">\n";
|
|
|
|
} else {
|
|
|
|
# advance raw git-diff output if needed
|
|
|
|
$patch_idx++ if defined $diffinfo;
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
|
2006-11-08 16:59:41 +00:00
|
|
|
# read and prepare patch information
|
2006-08-25 18:59:39 +00:00
|
|
|
if (ref($difftree->[$patch_idx]) eq "HASH") {
|
2006-11-08 16:59:41 +00:00
|
|
|
# pre-parsed (or generated by hand)
|
2006-08-25 18:59:39 +00:00
|
|
|
$diffinfo = $difftree->[$patch_idx];
|
|
|
|
} else {
|
|
|
|
$diffinfo = parse_difftree_raw_line($difftree->[$patch_idx]);
|
|
|
|
}
|
2006-11-08 16:59:41 +00:00
|
|
|
$from{'file'} = $diffinfo->{'from_file'} || $diffinfo->{'file'};
|
|
|
|
$to{'file'} = $diffinfo->{'to_file'} || $diffinfo->{'file'};
|
|
|
|
if ($diffinfo->{'status'} ne "A") { # not new (added) file
|
|
|
|
$from{'href'} = href(action=>"blob", hash_base=>$hash_parent,
|
|
|
|
hash=>$diffinfo->{'from_id'},
|
|
|
|
file_name=>$from{'file'});
|
2007-01-07 01:52:23 +00:00
|
|
|
} else {
|
|
|
|
delete $from{'href'};
|
2006-11-08 16:59:41 +00:00
|
|
|
}
|
|
|
|
if ($diffinfo->{'status'} ne "D") { # not deleted file
|
|
|
|
$to{'href'} = href(action=>"blob", hash_base=>$hash,
|
|
|
|
hash=>$diffinfo->{'to_id'},
|
|
|
|
file_name=>$to{'file'});
|
2007-01-07 01:52:23 +00:00
|
|
|
} else {
|
|
|
|
delete $to{'href'};
|
2006-11-08 16:59:41 +00:00
|
|
|
}
|
2006-11-18 22:35:39 +00:00
|
|
|
# this is first patch for raw difftree line with $patch_idx index
|
|
|
|
# we index @$difftree array from 0, but number patches from 1
|
|
|
|
print "<div class=\"patch\" id=\"patch". ($patch_idx+1) ."\">\n";
|
2006-11-08 16:59:41 +00:00
|
|
|
}
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
|
2006-11-18 22:35:39 +00:00
|
|
|
# print "git diff" header
|
|
|
|
$patch_line = shift @diff_header;
|
|
|
|
$patch_line =~ s!^(diff (.*?) )"?a/.*$!$1!;
|
|
|
|
if ($from{'href'}) {
|
|
|
|
$patch_line .= $cgi->a({-href => $from{'href'}, -class => "path"},
|
|
|
|
'a/' . esc_path($from{'file'}));
|
|
|
|
} else { # file was added
|
|
|
|
$patch_line .= 'a/' . esc_path($from{'file'});
|
|
|
|
}
|
|
|
|
$patch_line .= ' ';
|
|
|
|
if ($to{'href'}) {
|
|
|
|
$patch_line .= $cgi->a({-href => $to{'href'}, -class => "path"},
|
|
|
|
'b/' . esc_path($to{'file'}));
|
|
|
|
} else { # file was deleted
|
|
|
|
$patch_line .= 'b/' . esc_path($to{'file'});
|
|
|
|
}
|
|
|
|
print "<div class=\"diff header\">$patch_line</div>\n";
|
|
|
|
|
|
|
|
# print extended diff header
|
|
|
|
print "<div class=\"diff extended_header\">\n" if (@diff_header > 0);
|
|
|
|
EXTENDED_HEADER:
|
|
|
|
foreach $patch_line (@diff_header) {
|
|
|
|
# match <path>
|
|
|
|
if ($patch_line =~ s!^((copy|rename) from ).*$!$1! && $from{'href'}) {
|
|
|
|
$patch_line .= $cgi->a({-href=>$from{'href'}, -class=>"path"},
|
2007-01-07 01:52:24 +00:00
|
|
|
esc_path($from{'file'}));
|
2006-11-18 22:35:39 +00:00
|
|
|
}
|
|
|
|
if ($patch_line =~ s!^((copy|rename) to ).*$!$1! && $to{'href'}) {
|
2007-01-07 01:52:24 +00:00
|
|
|
$patch_line .= $cgi->a({-href=>$to{'href'}, -class=>"path"},
|
|
|
|
esc_path($to{'file'}));
|
2006-11-18 22:35:39 +00:00
|
|
|
}
|
|
|
|
# match <mode>
|
|
|
|
if ($patch_line =~ m/\s(\d{6})$/) {
|
|
|
|
$patch_line .= '<span class="info"> (' .
|
|
|
|
file_type_long($1) .
|
|
|
|
')</span>';
|
|
|
|
}
|
|
|
|
# match <hash>
|
|
|
|
if ($patch_line =~ m/^index/) {
|
|
|
|
my ($from_link, $to_link);
|
|
|
|
if ($from{'href'}) {
|
|
|
|
$from_link = $cgi->a({-href=>$from{'href'}, -class=>"hash"},
|
|
|
|
substr($diffinfo->{'from_id'},0,7));
|
|
|
|
} else {
|
|
|
|
$from_link = '0' x 7;
|
2006-11-08 16:59:41 +00:00
|
|
|
}
|
2006-11-18 22:35:39 +00:00
|
|
|
if ($to{'href'}) {
|
|
|
|
$to_link = $cgi->a({-href=>$to{'href'}, -class=>"hash"},
|
|
|
|
substr($diffinfo->{'to_id'},0,7));
|
|
|
|
} else {
|
|
|
|
$to_link = '0' x 7;
|
2006-11-08 16:59:41 +00:00
|
|
|
}
|
2006-11-18 22:35:39 +00:00
|
|
|
#affirm {
|
|
|
|
# my ($from_hash, $to_hash) =
|
|
|
|
# ($patch_line =~ m/^index ([0-9a-fA-F]{40})..([0-9a-fA-F]{40})/);
|
|
|
|
# my ($from_id, $to_id) =
|
|
|
|
# ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
|
|
|
|
# ($from_hash eq $from_id) && ($to_hash eq $to_id);
|
|
|
|
#} if DEBUG;
|
|
|
|
my ($from_id, $to_id) = ($diffinfo->{'from_id'}, $diffinfo->{'to_id'});
|
|
|
|
$patch_line =~ s!$from_id\.\.$to_id!$from_link..$to_link!;
|
|
|
|
}
|
|
|
|
print $patch_line . "<br/>\n";
|
|
|
|
}
|
|
|
|
print "</div>\n" if (@diff_header > 0); # class="diff extended_header"
|
|
|
|
|
|
|
|
# from-file/to-file diff header
|
|
|
|
$patch_line = $last_patch_line;
|
2007-01-09 23:07:43 +00:00
|
|
|
if (! $patch_line) {
|
|
|
|
print "</div>\n"; # class="patch"
|
|
|
|
last PATCH;
|
|
|
|
}
|
2007-01-07 01:52:25 +00:00
|
|
|
next PATCH if ($patch_line =~ m/^diff /);
|
2006-11-18 22:35:39 +00:00
|
|
|
#assert($patch_line =~ m/^---/) if DEBUG;
|
2007-01-07 01:52:27 +00:00
|
|
|
if ($from{'href'} && $patch_line =~ m!^--- "?a/!) {
|
2006-11-18 22:35:39 +00:00
|
|
|
$patch_line = '--- a/' .
|
|
|
|
$cgi->a({-href=>$from{'href'}, -class=>"path"},
|
|
|
|
esc_path($from{'file'}));
|
|
|
|
}
|
|
|
|
print "<div class=\"diff from_file\">$patch_line</div>\n";
|
2006-11-08 16:59:41 +00:00
|
|
|
|
2006-11-18 22:35:39 +00:00
|
|
|
$patch_line = <$fd>;
|
|
|
|
chomp $patch_line;
|
2006-08-25 19:04:13 +00:00
|
|
|
|
2006-11-18 22:35:39 +00:00
|
|
|
#assert($patch_line =~ m/^+++/) if DEBUG;
|
2007-01-07 01:52:27 +00:00
|
|
|
if ($to{'href'} && $patch_line =~ m!^\+\+\+ "?b/!) {
|
2006-11-18 22:35:39 +00:00
|
|
|
$patch_line = '+++ b/' .
|
|
|
|
$cgi->a({-href=>$to{'href'}, -class=>"path"},
|
|
|
|
esc_path($to{'file'}));
|
|
|
|
}
|
|
|
|
print "<div class=\"diff to_file\">$patch_line</div>\n";
|
2006-08-25 19:04:13 +00:00
|
|
|
|
2006-11-18 22:35:39 +00:00
|
|
|
# the patch itself
|
|
|
|
LINE:
|
|
|
|
while ($patch_line = <$fd>) {
|
|
|
|
chomp $patch_line;
|
2006-08-25 19:04:13 +00:00
|
|
|
|
2006-11-18 22:35:39 +00:00
|
|
|
next PATCH if ($patch_line =~ m/^diff /);
|
2006-08-25 19:04:13 +00:00
|
|
|
|
2006-11-18 22:35:40 +00:00
|
|
|
print format_diff_line($patch_line, \%from, \%to);
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
}
|
|
|
|
|
2006-11-18 22:35:39 +00:00
|
|
|
} continue {
|
|
|
|
print "</div>\n"; # class="patch"
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
print "</div>\n"; # class="patchset"
|
|
|
|
}
|
|
|
|
|
|
|
|
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
|
|
|
|
|
2006-10-24 03:33:17 +00:00
|
|
|
sub git_project_list_body {
|
|
|
|
my ($projlist, $order, $from, $to, $extra, $no_header) = @_;
|
|
|
|
|
2006-11-08 06:00:45 +00:00
|
|
|
my ($check_forks) = gitweb_check_feature('forks');
|
2006-10-24 03:33:17 +00:00
|
|
|
|
|
|
|
my @projects;
|
|
|
|
foreach my $pr (@$projlist) {
|
|
|
|
my (@aa) = git_get_last_activity($pr->{'path'});
|
|
|
|
unless (@aa) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
($pr->{'age'}, $pr->{'age_string'}) = @aa;
|
|
|
|
if (!defined $pr->{'descr'}) {
|
|
|
|
my $descr = git_get_project_description($pr->{'path'}) || "";
|
2006-11-26 01:18:26 +00:00
|
|
|
$pr->{'descr_long'} = to_utf8($descr);
|
2006-10-24 03:33:17 +00:00
|
|
|
$pr->{'descr'} = chop_str($descr, 25, 5);
|
|
|
|
}
|
|
|
|
if (!defined $pr->{'owner'}) {
|
|
|
|
$pr->{'owner'} = get_file_owner("$projectroot/$pr->{'path'}") || "";
|
|
|
|
}
|
|
|
|
if ($check_forks) {
|
|
|
|
my $pname = $pr->{'path'};
|
2006-11-08 06:37:17 +00:00
|
|
|
if (($pname =~ s/\.git$//) &&
|
|
|
|
($pname !~ /\/$/) &&
|
|
|
|
(-d "$projectroot/$pname")) {
|
|
|
|
$pr->{'forks'} = "-d $projectroot/$pname";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
$pr->{'forks'} = 0;
|
|
|
|
}
|
2006-10-24 03:33:17 +00:00
|
|
|
}
|
|
|
|
push @projects, $pr;
|
|
|
|
}
|
|
|
|
|
|
|
|
$order ||= "project";
|
|
|
|
$from = 0 unless defined $from;
|
|
|
|
$to = $#projects if (!defined $to || $#projects < $to);
|
|
|
|
|
|
|
|
print "<table class=\"project_list\">\n";
|
|
|
|
unless ($no_header) {
|
|
|
|
print "<tr>\n";
|
|
|
|
if ($check_forks) {
|
|
|
|
print "<th></th>\n";
|
|
|
|
}
|
|
|
|
if ($order eq "project") {
|
|
|
|
@projects = sort {$a->{'path'} cmp $b->{'path'}} @projects;
|
|
|
|
print "<th>Project</th>\n";
|
|
|
|
} else {
|
|
|
|
print "<th>" .
|
|
|
|
$cgi->a({-href => href(project=>undef, order=>'project'),
|
2006-11-26 01:18:26 +00:00
|
|
|
-class => "header"}, "Project") .
|
2006-10-24 03:33:17 +00:00
|
|
|
"</th>\n";
|
|
|
|
}
|
|
|
|
if ($order eq "descr") {
|
|
|
|
@projects = sort {$a->{'descr'} cmp $b->{'descr'}} @projects;
|
|
|
|
print "<th>Description</th>\n";
|
|
|
|
} else {
|
|
|
|
print "<th>" .
|
|
|
|
$cgi->a({-href => href(project=>undef, order=>'descr'),
|
2006-11-26 01:18:26 +00:00
|
|
|
-class => "header"}, "Description") .
|
2006-10-24 03:33:17 +00:00
|
|
|
"</th>\n";
|
|
|
|
}
|
|
|
|
if ($order eq "owner") {
|
|
|
|
@projects = sort {$a->{'owner'} cmp $b->{'owner'}} @projects;
|
|
|
|
print "<th>Owner</th>\n";
|
|
|
|
} else {
|
|
|
|
print "<th>" .
|
|
|
|
$cgi->a({-href => href(project=>undef, order=>'owner'),
|
2006-11-26 01:18:26 +00:00
|
|
|
-class => "header"}, "Owner") .
|
2006-10-24 03:33:17 +00:00
|
|
|
"</th>\n";
|
|
|
|
}
|
|
|
|
if ($order eq "age") {
|
|
|
|
@projects = sort {$a->{'age'} <=> $b->{'age'}} @projects;
|
|
|
|
print "<th>Last Change</th>\n";
|
|
|
|
} else {
|
|
|
|
print "<th>" .
|
|
|
|
$cgi->a({-href => href(project=>undef, order=>'age'),
|
2006-11-26 01:18:26 +00:00
|
|
|
-class => "header"}, "Last Change") .
|
2006-10-24 03:33:17 +00:00
|
|
|
"</th>\n";
|
|
|
|
}
|
|
|
|
print "<th></th>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
my $alternate = 1;
|
|
|
|
for (my $i = $from; $i <= $to; $i++) {
|
|
|
|
my $pr = $projects[$i];
|
|
|
|
if ($alternate) {
|
|
|
|
print "<tr class=\"dark\">\n";
|
|
|
|
} else {
|
|
|
|
print "<tr class=\"light\">\n";
|
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
|
|
|
if ($check_forks) {
|
|
|
|
print "<td>";
|
|
|
|
if ($pr->{'forks'}) {
|
2006-11-08 06:37:17 +00:00
|
|
|
print "<!-- $pr->{'forks'} -->\n";
|
2006-10-24 03:33:17 +00:00
|
|
|
print $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "+");
|
|
|
|
}
|
|
|
|
print "</td>\n";
|
|
|
|
}
|
|
|
|
print "<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
|
|
|
|
-class => "list"}, esc_html($pr->{'path'})) . "</td>\n" .
|
2006-11-26 01:18:26 +00:00
|
|
|
"<td>" . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary"),
|
|
|
|
-class => "list", -title => $pr->{'descr_long'}},
|
|
|
|
esc_html($pr->{'descr'})) . "</td>\n" .
|
2006-10-24 03:33:17 +00:00
|
|
|
"<td><i>" . chop_str($pr->{'owner'}, 15) . "</i></td>\n";
|
|
|
|
print "<td class=\"". age_class($pr->{'age'}) . "\">" .
|
|
|
|
$pr->{'age_string'} . "</td>\n" .
|
|
|
|
"<td class=\"link\">" .
|
|
|
|
$cgi->a({-href => href(project=>$pr->{'path'}, action=>"summary")}, "summary") . " | " .
|
2006-11-15 20:37:50 +00:00
|
|
|
$cgi->a({-href => href(project=>$pr->{'path'}, action=>"shortlog")}, "shortlog") . " | " .
|
2006-10-24 03:33:17 +00:00
|
|
|
$cgi->a({-href => href(project=>$pr->{'path'}, action=>"log")}, "log") . " | " .
|
|
|
|
$cgi->a({-href => href(project=>$pr->{'path'}, action=>"tree")}, "tree") .
|
|
|
|
($pr->{'forks'} ? " | " . $cgi->a({-href => href(project=>$pr->{'path'}, action=>"forks")}, "forks") : '') .
|
|
|
|
"</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
if (defined $extra) {
|
|
|
|
print "<tr>\n";
|
|
|
|
if ($check_forks) {
|
|
|
|
print "<td></td>\n";
|
|
|
|
}
|
|
|
|
print "<td colspan=\"5\">$extra</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
print "</table>\n";
|
|
|
|
}
|
|
|
|
|
2006-07-31 09:22:13 +00:00
|
|
|
sub git_shortlog_body {
|
|
|
|
# uses global variable $project
|
2006-12-24 14:31:44 +00:00
|
|
|
my ($commitlist, $from, $to, $refs, $extra) = @_;
|
2006-08-20 06:23:04 +00:00
|
|
|
|
2006-12-22 19:38:14 +00:00
|
|
|
my $have_snapshot = gitweb_have_snapshot();
|
|
|
|
|
2006-07-31 09:22:13 +00:00
|
|
|
$from = 0 unless defined $from;
|
2006-12-24 14:31:44 +00:00
|
|
|
$to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
|
2006-07-31 09:22:13 +00:00
|
|
|
|
|
|
|
print "<table class=\"shortlog\" cellspacing=\"0\">\n";
|
gitweb: "alternate" starts with shade (i.e. 1)
When displaying a list of rows (difftree, shortlog, etc),
the first entry is now printed shaded, i.e. alternate is
initialized to 1, as opposed to non-shaded (alternate
initialized to 0).
This solves the problem when there is only one row to
display -- it is displayed shaded to visually indicate that
it is "active", part of a "list", etc.
(Compare this to the trivial case of more than one entry,
where the rows have alternating shade, thus suggesting
being part of a "list" of "active" entries, etc.)
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-28 23:47:50 +00:00
|
|
|
my $alternate = 1;
|
2006-07-31 09:22:13 +00:00
|
|
|
for (my $i = $from; $i <= $to; $i++) {
|
2006-12-24 14:31:44 +00:00
|
|
|
my %co = %{$commitlist->[$i]};
|
|
|
|
my $commit = $co{'id'};
|
2006-08-14 00:05:47 +00:00
|
|
|
my $ref = format_ref_marker($refs, $commit);
|
2006-07-31 09:22:13 +00:00
|
|
|
if ($alternate) {
|
|
|
|
print "<tr class=\"dark\">\n";
|
|
|
|
} else {
|
|
|
|
print "<tr class=\"light\">\n";
|
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
|
|
|
# git_summary() used print "<td><i>$co{'age_string'}</i></td>\n" .
|
|
|
|
print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
|
|
|
|
"<td><i>" . esc_html(chop_str($co{'author_name'}, 10)) . "</i></td>\n" .
|
|
|
|
"<td>";
|
2006-08-22 14:52:50 +00:00
|
|
|
print format_subject_html($co{'title'}, $co{'title_short'},
|
|
|
|
href(action=>"commit", hash=>$commit), $ref);
|
2006-07-31 09:22:13 +00:00
|
|
|
print "</td>\n" .
|
|
|
|
"<td class=\"link\">" .
|
2006-10-24 03:36:10 +00:00
|
|
|
$cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") . " | " .
|
2006-09-22 01:19:44 +00:00
|
|
|
$cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") . " | " .
|
2006-10-06 13:57:52 +00:00
|
|
|
$cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree");
|
2006-12-22 19:38:14 +00:00
|
|
|
if ($have_snapshot) {
|
2006-10-06 13:57:52 +00:00
|
|
|
print " | " . $cgi->a({-href => href(action=>"snapshot", hash=>$commit)}, "snapshot");
|
|
|
|
}
|
2006-08-17 15:29:46 +00:00
|
|
|
print "</td>\n" .
|
2006-07-31 09:22:13 +00:00
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
if (defined $extra) {
|
|
|
|
print "<tr>\n" .
|
|
|
|
"<td colspan=\"4\">$extra</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
print "</table>\n";
|
|
|
|
}
|
|
|
|
|
2006-08-14 00:09:08 +00:00
|
|
|
sub git_history_body {
|
|
|
|
# Warning: assumes constant type (blob or tree) during history
|
2006-12-24 14:31:48 +00:00
|
|
|
my ($commitlist, $from, $to, $refs, $hash_base, $ftype, $extra) = @_;
|
2006-09-10 22:36:04 +00:00
|
|
|
|
|
|
|
$from = 0 unless defined $from;
|
2006-12-24 14:31:48 +00:00
|
|
|
$to = $#{$commitlist} unless (defined $to && $to <= $#{$commitlist});
|
2006-08-14 00:09:08 +00:00
|
|
|
|
|
|
|
print "<table class=\"history\" cellspacing=\"0\">\n";
|
gitweb: "alternate" starts with shade (i.e. 1)
When displaying a list of rows (difftree, shortlog, etc),
the first entry is now printed shaded, i.e. alternate is
initialized to 1, as opposed to non-shaded (alternate
initialized to 0).
This solves the problem when there is only one row to
display -- it is displayed shaded to visually indicate that
it is "active", part of a "list", etc.
(Compare this to the trivial case of more than one entry,
where the rows have alternating shade, thus suggesting
being part of a "list" of "active" entries, etc.)
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-28 23:47:50 +00:00
|
|
|
my $alternate = 1;
|
2006-09-10 22:36:04 +00:00
|
|
|
for (my $i = $from; $i <= $to; $i++) {
|
2006-12-24 14:31:48 +00:00
|
|
|
my %co = %{$commitlist->[$i]};
|
2006-08-14 00:09:08 +00:00
|
|
|
if (!%co) {
|
|
|
|
next;
|
|
|
|
}
|
2006-12-24 14:31:48 +00:00
|
|
|
my $commit = $co{'id'};
|
2006-08-14 00:09:08 +00:00
|
|
|
|
|
|
|
my $ref = format_ref_marker($refs, $commit);
|
|
|
|
|
|
|
|
if ($alternate) {
|
|
|
|
print "<tr class=\"dark\">\n";
|
|
|
|
} else {
|
|
|
|
print "<tr class=\"light\">\n";
|
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
|
|
|
print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
|
|
|
|
# shortlog uses chop_str($co{'author_name'}, 10)
|
|
|
|
"<td><i>" . esc_html(chop_str($co{'author_name'}, 15, 3)) . "</i></td>\n" .
|
|
|
|
"<td>";
|
|
|
|
# originally git_history used chop_str($co{'title'}, 50)
|
2006-08-22 14:52:50 +00:00
|
|
|
print format_subject_html($co{'title'}, $co{'title_short'},
|
|
|
|
href(action=>"commit", hash=>$commit), $ref);
|
2006-08-14 00:09:08 +00:00
|
|
|
print "</td>\n" .
|
|
|
|
"<td class=\"link\">" .
|
2006-09-29 00:21:07 +00:00
|
|
|
$cgi->a({-href => href(action=>$ftype, hash_base=>$commit, file_name=>$file_name)}, $ftype) . " | " .
|
|
|
|
$cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff");
|
2006-08-14 00:09:08 +00:00
|
|
|
|
|
|
|
if ($ftype eq 'blob') {
|
|
|
|
my $blob_current = git_get_hash_by_path($hash_base, $file_name);
|
|
|
|
my $blob_parent = git_get_hash_by_path($commit, $file_name);
|
|
|
|
if (defined $blob_current && defined $blob_parent &&
|
|
|
|
$blob_current ne $blob_parent) {
|
|
|
|
print " | " .
|
2006-08-24 21:53:54 +00:00
|
|
|
$cgi->a({-href => href(action=>"blobdiff",
|
|
|
|
hash=>$blob_current, hash_parent=>$blob_parent,
|
|
|
|
hash_base=>$hash_base, hash_parent_base=>$commit,
|
|
|
|
file_name=>$file_name)},
|
2006-08-14 00:09:08 +00:00
|
|
|
"diff to current");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
print "</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
if (defined $extra) {
|
|
|
|
print "<tr>\n" .
|
|
|
|
"<td colspan=\"4\">$extra</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
print "</table>\n";
|
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
sub git_tags_body {
|
|
|
|
# uses global variable $project
|
|
|
|
my ($taglist, $from, $to, $extra) = @_;
|
|
|
|
$from = 0 unless defined $from;
|
|
|
|
$to = $#{$taglist} if (!defined $to || $#{$taglist} < $to);
|
|
|
|
|
|
|
|
print "<table class=\"tags\" cellspacing=\"0\">\n";
|
gitweb: "alternate" starts with shade (i.e. 1)
When displaying a list of rows (difftree, shortlog, etc),
the first entry is now printed shaded, i.e. alternate is
initialized to 1, as opposed to non-shaded (alternate
initialized to 0).
This solves the problem when there is only one row to
display -- it is displayed shaded to visually indicate that
it is "active", part of a "list", etc.
(Compare this to the trivial case of more than one entry,
where the rows have alternating shade, thus suggesting
being part of a "list" of "active" entries, etc.)
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-28 23:47:50 +00:00
|
|
|
my $alternate = 1;
|
2006-07-31 19:22:15 +00:00
|
|
|
for (my $i = $from; $i <= $to; $i++) {
|
|
|
|
my $entry = $taglist->[$i];
|
|
|
|
my %tag = %$entry;
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
my $comment = $tag{'subject'};
|
2006-07-31 19:22:15 +00:00
|
|
|
my $comment_short;
|
|
|
|
if (defined $comment) {
|
|
|
|
$comment_short = chop_str($comment, 30, 5);
|
|
|
|
}
|
|
|
|
if ($alternate) {
|
|
|
|
print "<tr class=\"dark\">\n";
|
|
|
|
} else {
|
|
|
|
print "<tr class=\"light\">\n";
|
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
2007-01-03 21:54:29 +00:00
|
|
|
if (defined $tag{'age'}) {
|
|
|
|
print "<td><i>$tag{'age'}</i></td>\n";
|
|
|
|
} else {
|
|
|
|
print "<td></td>\n";
|
|
|
|
}
|
|
|
|
print "<td>" .
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'}),
|
2006-08-22 10:38:59 +00:00
|
|
|
-class => "list name"}, esc_html($tag{'name'})) .
|
2006-07-31 19:22:15 +00:00
|
|
|
"</td>\n" .
|
|
|
|
"<td>";
|
|
|
|
if (defined $comment) {
|
2006-08-22 14:52:50 +00:00
|
|
|
print format_subject_html($comment, $comment_short,
|
|
|
|
href(action=>"tag", hash=>$tag{'id'}));
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
|
|
|
print "</td>\n" .
|
|
|
|
"<td class=\"selflink\">";
|
|
|
|
if ($tag{'type'} eq "tag") {
|
2006-08-15 22:24:30 +00:00
|
|
|
print $cgi->a({-href => href(action=>"tag", hash=>$tag{'id'})}, "tag");
|
2006-07-31 19:22:15 +00:00
|
|
|
} else {
|
|
|
|
print " ";
|
|
|
|
}
|
|
|
|
print "</td>\n" .
|
|
|
|
"<td class=\"link\">" . " | " .
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(action=>$tag{'reftype'}, hash=>$tag{'refid'})}, $tag{'reftype'});
|
2006-07-31 19:22:15 +00:00
|
|
|
if ($tag{'reftype'} eq "commit") {
|
2006-08-15 22:24:30 +00:00
|
|
|
print " | " . $cgi->a({-href => href(action=>"shortlog", hash=>$tag{'name'})}, "shortlog") .
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
" | " . $cgi->a({-href => href(action=>"log", hash=>$tag{'name'})}, "log");
|
2006-07-31 19:22:15 +00:00
|
|
|
} elsif ($tag{'reftype'} eq "blob") {
|
2006-08-15 22:24:30 +00:00
|
|
|
print " | " . $cgi->a({-href => href(action=>"blob_plain", hash=>$tag{'refid'})}, "raw");
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
|
|
|
print "</td>\n" .
|
|
|
|
"</tr>";
|
|
|
|
}
|
|
|
|
if (defined $extra) {
|
|
|
|
print "<tr>\n" .
|
|
|
|
"<td colspan=\"5\">$extra</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
print "</table>\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
sub git_heads_body {
|
|
|
|
# uses global variable $project
|
2006-09-19 12:33:22 +00:00
|
|
|
my ($headlist, $head, $from, $to, $extra) = @_;
|
2006-07-31 19:22:15 +00:00
|
|
|
$from = 0 unless defined $from;
|
2006-09-19 12:33:22 +00:00
|
|
|
$to = $#{$headlist} if (!defined $to || $#{$headlist} < $to);
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
print "<table class=\"heads\" cellspacing=\"0\">\n";
|
gitweb: "alternate" starts with shade (i.e. 1)
When displaying a list of rows (difftree, shortlog, etc),
the first entry is now printed shaded, i.e. alternate is
initialized to 1, as opposed to non-shaded (alternate
initialized to 0).
This solves the problem when there is only one row to
display -- it is displayed shaded to visually indicate that
it is "active", part of a "list", etc.
(Compare this to the trivial case of more than one entry,
where the rows have alternating shade, thus suggesting
being part of a "list" of "active" entries, etc.)
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-28 23:47:50 +00:00
|
|
|
my $alternate = 1;
|
2006-07-31 19:22:15 +00:00
|
|
|
for (my $i = $from; $i <= $to; $i++) {
|
2006-09-19 12:33:22 +00:00
|
|
|
my $entry = $headlist->[$i];
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
my %ref = %$entry;
|
|
|
|
my $curr = $ref{'id'} eq $head;
|
2006-07-31 19:22:15 +00:00
|
|
|
if ($alternate) {
|
|
|
|
print "<tr class=\"dark\">\n";
|
|
|
|
} else {
|
|
|
|
print "<tr class=\"light\">\n";
|
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
print "<td><i>$ref{'age'}</i></td>\n" .
|
|
|
|
($curr ? "<td class=\"current_head\">" : "<td>") .
|
|
|
|
$cgi->a({-href => href(action=>"shortlog", hash=>$ref{'name'}),
|
|
|
|
-class => "list name"},esc_html($ref{'name'})) .
|
2006-07-31 19:22:15 +00:00
|
|
|
"</td>\n" .
|
|
|
|
"<td class=\"link\">" .
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
$cgi->a({-href => href(action=>"shortlog", hash=>$ref{'name'})}, "shortlog") . " | " .
|
|
|
|
$cgi->a({-href => href(action=>"log", hash=>$ref{'name'})}, "log") . " | " .
|
|
|
|
$cgi->a({-href => href(action=>"tree", hash=>$ref{'name'}, hash_base=>$ref{'name'})}, "tree") .
|
2006-07-31 19:22:15 +00:00
|
|
|
"</td>\n" .
|
|
|
|
"</tr>";
|
|
|
|
}
|
|
|
|
if (defined $extra) {
|
|
|
|
print "<tr>\n" .
|
|
|
|
"<td colspan=\"3\">$extra</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
print "</table>\n";
|
|
|
|
}
|
|
|
|
|
2006-12-23 14:57:12 +00:00
|
|
|
sub git_search_grep_body {
|
2006-12-24 14:31:46 +00:00
|
|
|
my ($commitlist, $from, $to, $extra) = @_;
|
2006-12-23 14:57:12 +00:00
|
|
|
$from = 0 unless defined $from;
|
2006-12-24 14:31:46 +00:00
|
|
|
$to = $#{$commitlist} if (!defined $to || $#{$commitlist} < $to);
|
2006-12-23 14:57:12 +00:00
|
|
|
|
|
|
|
print "<table class=\"grep\" cellspacing=\"0\">\n";
|
|
|
|
my $alternate = 1;
|
|
|
|
for (my $i = $from; $i <= $to; $i++) {
|
2006-12-24 14:31:46 +00:00
|
|
|
my %co = %{$commitlist->[$i]};
|
2006-12-23 14:57:12 +00:00
|
|
|
if (!%co) {
|
|
|
|
next;
|
|
|
|
}
|
2006-12-24 14:31:46 +00:00
|
|
|
my $commit = $co{'id'};
|
2006-12-23 14:57:12 +00:00
|
|
|
if ($alternate) {
|
|
|
|
print "<tr class=\"dark\">\n";
|
|
|
|
} else {
|
|
|
|
print "<tr class=\"light\">\n";
|
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
|
|
|
print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
|
|
|
|
"<td><i>" . esc_html(chop_str($co{'author_name'}, 15, 5)) . "</i></td>\n" .
|
|
|
|
"<td>" .
|
|
|
|
$cgi->a({-href => href(action=>"commit", hash=>$co{'id'}), -class => "list subject"},
|
|
|
|
esc_html(chop_str($co{'title'}, 50)) . "<br/>");
|
|
|
|
my $comment = $co{'comment'};
|
|
|
|
foreach my $line (@$comment) {
|
|
|
|
if ($line =~ m/^(.*)($searchtext)(.*)$/i) {
|
|
|
|
my $lead = esc_html($1) || "";
|
|
|
|
$lead = chop_str($lead, 30, 10);
|
|
|
|
my $match = esc_html($2) || "";
|
|
|
|
my $trail = esc_html($3) || "";
|
|
|
|
$trail = chop_str($trail, 30, 10);
|
|
|
|
my $text = "$lead<span class=\"match\">$match</span>$trail";
|
|
|
|
print chop_str($text, 80, 5) . "<br/>\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
print "</td>\n" .
|
|
|
|
"<td class=\"link\">" .
|
|
|
|
$cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
|
|
|
|
" | " .
|
|
|
|
$cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
|
|
|
|
print "</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
if (defined $extra) {
|
|
|
|
print "<tr>\n" .
|
|
|
|
"<td colspan=\"3\">$extra</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
|
|
|
print "</table>\n";
|
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
## ======================================================================
|
|
|
|
## ======================================================================
|
|
|
|
## actions
|
|
|
|
|
|
|
|
sub git_project_list {
|
2006-08-01 00:59:12 +00:00
|
|
|
my $order = $cgi->param('o');
|
|
|
|
if (defined $order && $order !~ m/project|descr|owner|age/) {
|
2006-08-05 11:15:24 +00:00
|
|
|
die_error(undef, "Unknown order parameter");
|
2006-08-01 00:59:12 +00:00
|
|
|
}
|
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
my @list = git_get_projects_list();
|
2006-07-31 19:22:15 +00:00
|
|
|
if (!@list) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "No projects found");
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
2006-08-01 00:59:12 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
git_header_html();
|
|
|
|
if (-f $home_text) {
|
|
|
|
print "<div class=\"index_include\">\n";
|
|
|
|
open (my $fd, $home_text);
|
|
|
|
print <$fd>;
|
|
|
|
close $fd;
|
|
|
|
print "</div>\n";
|
2006-07-31 09:22:13 +00:00
|
|
|
}
|
2006-10-24 03:33:17 +00:00
|
|
|
git_project_list_body(\@list, $order);
|
|
|
|
git_footer_html();
|
|
|
|
}
|
|
|
|
|
|
|
|
sub git_forks {
|
|
|
|
my $order = $cgi->param('o');
|
|
|
|
if (defined $order && $order !~ m/project|descr|owner|age/) {
|
|
|
|
die_error(undef, "Unknown order parameter");
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
2006-10-24 03:33:17 +00:00
|
|
|
|
|
|
|
my @list = git_get_projects_list($project);
|
|
|
|
if (!@list) {
|
|
|
|
die_error(undef, "No forks found");
|
2006-07-31 09:22:13 +00:00
|
|
|
}
|
2006-10-24 03:33:17 +00:00
|
|
|
|
|
|
|
git_header_html();
|
|
|
|
git_print_page_nav('','');
|
|
|
|
git_print_header_div('summary', "$project forks");
|
|
|
|
git_project_list_body(\@list, $order);
|
2006-07-31 19:22:15 +00:00
|
|
|
git_footer_html();
|
2006-07-31 09:22:13 +00:00
|
|
|
}
|
|
|
|
|
2006-09-15 02:56:03 +00:00
|
|
|
sub git_project_index {
|
2006-10-24 03:33:17 +00:00
|
|
|
my @projects = git_get_projects_list($project);
|
2006-09-15 02:56:03 +00:00
|
|
|
|
|
|
|
print $cgi->header(
|
|
|
|
-type => 'text/plain',
|
|
|
|
-charset => 'utf-8',
|
2006-09-25 23:59:43 +00:00
|
|
|
-content_disposition => 'inline; filename="index.aux"');
|
2006-09-15 02:56:03 +00:00
|
|
|
|
|
|
|
foreach my $pr (@projects) {
|
|
|
|
if (!exists $pr->{'owner'}) {
|
2007-01-03 15:03:01 +00:00
|
|
|
$pr->{'owner'} = get_file_owner("$projectroot/$pr->{'path'}");
|
2006-09-15 02:56:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
my ($path, $owner) = ($pr->{'path'}, $pr->{'owner'});
|
|
|
|
# quote as in CGI::Util::encode, but keep the slash, and use '+' for ' '
|
|
|
|
$path =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
|
|
|
|
$owner =~ s/([^a-zA-Z0-9_.\-\/ ])/sprintf("%%%02X", ord($1))/eg;
|
|
|
|
$path =~ s/ /\+/g;
|
|
|
|
$owner =~ s/ /\+/g;
|
|
|
|
|
|
|
|
print "$path $owner\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:23:12 +00:00
|
|
|
sub git_summary {
|
2006-08-14 00:05:47 +00:00
|
|
|
my $descr = git_get_project_description($project) || "none";
|
2006-12-22 19:38:15 +00:00
|
|
|
my %co = parse_commit("HEAD");
|
2006-08-14 00:05:47 +00:00
|
|
|
my %cd = parse_date($co{'committer_epoch'}, $co{'committer_tz'});
|
2006-12-22 19:38:15 +00:00
|
|
|
my $head = $co{'id'};
|
2005-08-07 18:23:12 +00:00
|
|
|
|
2006-08-14 00:10:06 +00:00
|
|
|
my $owner = git_get_project_owner($project);
|
2005-08-07 18:23:12 +00:00
|
|
|
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
my $refs = git_get_references();
|
2006-12-19 12:08:54 +00:00
|
|
|
# These get_*_list functions return one more to allow us to see if
|
|
|
|
# there are more ...
|
|
|
|
my @taglist = git_get_tags_list(16);
|
|
|
|
my @headlist = git_get_heads_list(16);
|
2006-10-24 03:33:17 +00:00
|
|
|
my @forklist;
|
2006-11-08 06:00:45 +00:00
|
|
|
my ($check_forks) = gitweb_check_feature('forks');
|
|
|
|
|
|
|
|
if ($check_forks) {
|
2006-10-24 03:33:17 +00:00
|
|
|
@forklist = git_get_projects_list($project);
|
|
|
|
}
|
2006-09-19 12:33:22 +00:00
|
|
|
|
2005-08-07 18:23:12 +00:00
|
|
|
git_header_html();
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_page_nav('summary','', $head);
|
2006-07-31 09:22:13 +00:00
|
|
|
|
2005-08-07 18:26:27 +00:00
|
|
|
print "<div class=\"title\"> </div>\n";
|
2005-08-07 18:25:42 +00:00
|
|
|
print "<table cellspacing=\"0\">\n" .
|
replace invalid utf8 sequences by UTF-8 REPLACEMENT CHARACTER (efbfbd)
I still strongly disagree with the git maintainers not to hint people,
to use the only sane default encoding for a distributed project,
which is utf8. I'm tired of hearing filesystem development arguments.
Git is a software offered to merge forth and back across the world
and not to provide a content neutral filesystem.
Btw: I have nothing against the ability to run git in a closed environment,
with a different encoding, that's fine, sure. But that is obviously not
the case for the projects on kernel.org. It's about sane defaults,
nothing else.
You have to make decisions guy, as always in life. The problems to
allow random encoded garbage in commit messages _without_ storing
the encoding, just makes zero sense. Eighter you introduce a per-commit
encoding field, if you insist on this craziness, or you define a default
encoding. Everything else is just lazy and does not solve any problem,
besides that you can claim now, that you are not responsible for the mess
in the repository.
Gitweb shows several commits at once, you allow various encodings committed
to the same repository, without any hint what that garbage from the
individual commits is encoded with. No idea why you don't get
the problem - it's unsolvable. If you merge different peoples work, you
have to speak a common language!
Kay Sievers <kay.sievers@vrfy.org>
2005-11-19 16:41:29 +00:00
|
|
|
"<tr><td>description</td><td>" . esc_html($descr) . "</td></tr>\n" .
|
2005-08-07 18:23:12 +00:00
|
|
|
"<tr><td>owner</td><td>$owner</td></tr>\n" .
|
2006-08-15 21:03:17 +00:00
|
|
|
"<tr><td>last change</td><td>$cd{'rfc2822'}</td></tr>\n";
|
2006-08-16 12:50:34 +00:00
|
|
|
# use per project git URL list in $projectroot/$project/cloneurl
|
|
|
|
# or make project git URL from git base URL and project name
|
2006-08-15 21:03:17 +00:00
|
|
|
my $url_tag = "URL";
|
2006-08-16 12:50:34 +00:00
|
|
|
my @url_list = git_get_project_url_list($project);
|
|
|
|
@url_list = map { "$_/$project" } @git_base_url_list unless @url_list;
|
|
|
|
foreach my $git_url (@url_list) {
|
|
|
|
next unless $git_url;
|
|
|
|
print "<tr><td>$url_tag</td><td>$git_url</td></tr>\n";
|
2006-08-15 21:03:17 +00:00
|
|
|
$url_tag = "";
|
|
|
|
}
|
|
|
|
print "</table>\n";
|
2006-07-31 09:22:13 +00:00
|
|
|
|
2006-10-24 03:23:46 +00:00
|
|
|
if (-s "$projectroot/$project/README.html") {
|
|
|
|
if (open my $fd, "$projectroot/$project/README.html") {
|
|
|
|
print "<div class=\"title\">readme</div>\n";
|
|
|
|
print $_ while (<$fd>);
|
|
|
|
close $fd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-19 12:08:54 +00:00
|
|
|
# we need to request one more than 16 (0..15) to check if
|
|
|
|
# those 16 are all
|
2006-12-24 14:31:44 +00:00
|
|
|
my @commitlist = parse_commits($head, 17);
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_header_div('shortlog');
|
2006-12-24 14:31:44 +00:00
|
|
|
git_shortlog_body(\@commitlist, 0, 15, $refs,
|
|
|
|
$#commitlist <= 15 ? undef :
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(action=>"shortlog")}, "..."));
|
2005-08-07 18:23:12 +00:00
|
|
|
|
2006-09-19 12:33:22 +00:00
|
|
|
if (@taglist) {
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_header_div('tags');
|
2006-09-19 12:33:22 +00:00
|
|
|
git_tags_body(\@taglist, 0, 15,
|
2006-12-19 12:08:54 +00:00
|
|
|
$#taglist <= 15 ? undef :
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(action=>"tags")}, "..."));
|
2005-08-07 18:23:12 +00:00
|
|
|
}
|
2005-08-07 18:24:35 +00:00
|
|
|
|
2006-09-19 12:33:22 +00:00
|
|
|
if (@headlist) {
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_header_div('heads');
|
2006-09-19 12:33:22 +00:00
|
|
|
git_heads_body(\@headlist, $head, 0, 15,
|
2006-12-19 12:08:54 +00:00
|
|
|
$#headlist <= 15 ? undef :
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(action=>"heads")}, "..."));
|
2005-08-07 18:24:35 +00:00
|
|
|
}
|
2006-07-31 09:22:13 +00:00
|
|
|
|
2006-10-24 03:33:17 +00:00
|
|
|
if (@forklist) {
|
|
|
|
git_print_header_div('forks');
|
|
|
|
git_project_list_body(\@forklist, undef, 0, 15,
|
2006-12-22 19:38:12 +00:00
|
|
|
$#forklist <= 15 ? undef :
|
2006-10-24 03:33:17 +00:00
|
|
|
$cgi->a({-href => href(action=>"forks")}, "..."),
|
|
|
|
'noheader');
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:23:12 +00:00
|
|
|
git_footer_html();
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:28:53 +00:00
|
|
|
sub git_tag {
|
2006-08-14 00:05:47 +00:00
|
|
|
my $head = git_get_head_hash($project);
|
2005-08-07 18:28:53 +00:00
|
|
|
git_header_html();
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_page_nav('','', $head,undef,$head);
|
|
|
|
my %tag = parse_tag($hash);
|
|
|
|
git_print_header_div('commit', esc_html($tag{'name'}), $hash);
|
2005-08-07 18:28:53 +00:00
|
|
|
print "<div class=\"title_text\">\n" .
|
|
|
|
"<table cellspacing=\"0\">\n" .
|
2005-08-07 22:02:39 +00:00
|
|
|
"<tr>\n" .
|
|
|
|
"<td>object</td>\n" .
|
2006-08-22 14:52:50 +00:00
|
|
|
"<td>" . $cgi->a({-class => "list", -href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
|
|
|
|
$tag{'object'}) . "</td>\n" .
|
|
|
|
"<td class=\"link\">" . $cgi->a({-href => href(action=>$tag{'type'}, hash=>$tag{'object'})},
|
|
|
|
$tag{'type'}) . "</td>\n" .
|
2005-08-07 22:02:39 +00:00
|
|
|
"</tr>\n";
|
2005-08-07 18:28:53 +00:00
|
|
|
if (defined($tag{'author'})) {
|
2006-08-14 00:05:47 +00:00
|
|
|
my %ad = parse_date($tag{'epoch'}, $tag{'tz'});
|
replace invalid utf8 sequences by UTF-8 REPLACEMENT CHARACTER (efbfbd)
I still strongly disagree with the git maintainers not to hint people,
to use the only sane default encoding for a distributed project,
which is utf8. I'm tired of hearing filesystem development arguments.
Git is a software offered to merge forth and back across the world
and not to provide a content neutral filesystem.
Btw: I have nothing against the ability to run git in a closed environment,
with a different encoding, that's fine, sure. But that is obviously not
the case for the projects on kernel.org. It's about sane defaults,
nothing else.
You have to make decisions guy, as always in life. The problems to
allow random encoded garbage in commit messages _without_ storing
the encoding, just makes zero sense. Eighter you introduce a per-commit
encoding field, if you insist on this craziness, or you define a default
encoding. Everything else is just lazy and does not solve any problem,
besides that you can claim now, that you are not responsible for the mess
in the repository.
Gitweb shows several commits at once, you allow various encodings committed
to the same repository, without any hint what that garbage from the
individual commits is encoded with. No idea why you don't get
the problem - it's unsolvable. If you merge different peoples work, you
have to speak a common language!
Kay Sievers <kay.sievers@vrfy.org>
2005-11-19 16:41:29 +00:00
|
|
|
print "<tr><td>author</td><td>" . esc_html($tag{'author'}) . "</td></tr>\n";
|
2006-08-22 14:52:50 +00:00
|
|
|
print "<tr><td></td><td>" . $ad{'rfc2822'} .
|
|
|
|
sprintf(" (%02d:%02d %s)", $ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'}) .
|
|
|
|
"</td></tr>\n";
|
2005-08-07 18:28:53 +00:00
|
|
|
}
|
|
|
|
print "</table>\n\n" .
|
|
|
|
"</div>\n";
|
|
|
|
print "<div class=\"page_body\">";
|
|
|
|
my $comment = $tag{'comment'};
|
|
|
|
foreach my $line (@$comment) {
|
2006-11-24 22:04:01 +00:00
|
|
|
chomp $line;
|
2006-11-24 21:25:50 +00:00
|
|
|
print esc_html($line, -nbsp=>1) . "<br/>\n";
|
2005-08-07 18:28:53 +00:00
|
|
|
}
|
|
|
|
print "</div>\n";
|
|
|
|
git_footer_html();
|
|
|
|
}
|
|
|
|
|
2006-07-23 20:34:55 +00:00
|
|
|
sub git_blame2 {
|
|
|
|
my $fd;
|
|
|
|
my $ftype;
|
2006-08-20 06:23:04 +00:00
|
|
|
|
2006-09-01 03:43:32 +00:00
|
|
|
my ($have_blame) = gitweb_check_feature('blame');
|
|
|
|
if (!$have_blame) {
|
2006-08-20 06:23:04 +00:00
|
|
|
die_error('403 Permission denied', "Permission denied");
|
|
|
|
}
|
2006-07-23 20:34:55 +00:00
|
|
|
die_error('404 Not Found', "File name not defined") if (!$file_name);
|
2006-08-14 00:05:47 +00:00
|
|
|
$hash_base ||= git_get_head_hash($project);
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Couldn't find base commit") unless ($hash_base);
|
2006-08-14 00:05:47 +00:00
|
|
|
my %co = parse_commit($hash_base)
|
2006-07-23 20:34:55 +00:00
|
|
|
or die_error(undef, "Reading commit failed");
|
|
|
|
if (!defined $hash) {
|
|
|
|
$hash = git_get_hash_by_path($hash_base, $file_name, "blob")
|
|
|
|
or die_error(undef, "Error looking up file");
|
|
|
|
}
|
|
|
|
$ftype = git_get_type($hash);
|
|
|
|
if ($ftype !~ "blob") {
|
2006-08-05 11:12:51 +00:00
|
|
|
die_error("400 Bad Request", "Object is not a blob");
|
2006-07-23 20:34:55 +00:00
|
|
|
}
|
2006-10-12 07:47:03 +00:00
|
|
|
open ($fd, "-|", git_cmd(), "blame", '-p', '--',
|
2006-10-05 20:55:58 +00:00
|
|
|
$file_name, $hash_base)
|
2006-08-05 11:13:53 +00:00
|
|
|
or die_error(undef, "Open git-blame failed");
|
2006-07-23 20:34:55 +00:00
|
|
|
git_header_html();
|
2006-07-30 13:01:07 +00:00
|
|
|
my $formats_nav =
|
2006-08-22 14:52:50 +00:00
|
|
|
$cgi->a({-href => href(action=>"blob", hash=>$hash, hash_base=>$hash_base, file_name=>$file_name)},
|
|
|
|
"blob") .
|
|
|
|
" | " .
|
2006-09-22 01:19:41 +00:00
|
|
|
$cgi->a({-href => href(action=>"history", hash=>$hash, hash_base=>$hash_base, file_name=>$file_name)},
|
|
|
|
"history") .
|
|
|
|
" | " .
|
2006-08-22 14:52:50 +00:00
|
|
|
$cgi->a({-href => href(action=>"blame", file_name=>$file_name)},
|
2006-09-22 01:19:53 +00:00
|
|
|
"HEAD");
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
|
|
|
|
git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
|
2006-08-17 17:39:29 +00:00
|
|
|
git_print_page_path($file_name, $ftype, $hash_base);
|
2006-08-04 22:09:59 +00:00
|
|
|
my @rev_color = (qw(light2 dark2));
|
2006-07-23 20:37:53 +00:00
|
|
|
my $num_colors = scalar(@rev_color);
|
|
|
|
my $current_color = 0;
|
|
|
|
my $last_rev;
|
2006-08-22 21:42:53 +00:00
|
|
|
print <<HTML;
|
|
|
|
<div class="page_body">
|
|
|
|
<table class="blame">
|
|
|
|
<tr><th>Commit</th><th>Line</th><th>Data</th></tr>
|
|
|
|
HTML
|
2006-10-05 20:55:58 +00:00
|
|
|
my %metainfo = ();
|
|
|
|
while (1) {
|
|
|
|
$_ = <$fd>;
|
|
|
|
last unless defined $_;
|
2006-10-11 07:30:05 +00:00
|
|
|
my ($full_rev, $orig_lineno, $lineno, $group_size) =
|
2006-10-05 20:55:58 +00:00
|
|
|
/^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/;
|
|
|
|
if (!exists $metainfo{$full_rev}) {
|
|
|
|
$metainfo{$full_rev} = {};
|
|
|
|
}
|
|
|
|
my $meta = $metainfo{$full_rev};
|
|
|
|
while (<$fd>) {
|
|
|
|
last if (s/^\t//);
|
|
|
|
if (/^(\S+) (.*)$/) {
|
|
|
|
$meta->{$1} = $2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
my $data = $_;
|
2006-11-24 22:04:01 +00:00
|
|
|
chomp $data;
|
2006-07-23 20:34:55 +00:00
|
|
|
my $rev = substr($full_rev, 0, 8);
|
2006-10-05 20:55:58 +00:00
|
|
|
my $author = $meta->{'author'};
|
|
|
|
my %date = parse_date($meta->{'author-time'},
|
|
|
|
$meta->{'author-tz'});
|
|
|
|
my $date = $date{'iso-tz'};
|
|
|
|
if ($group_size) {
|
2006-07-23 20:37:53 +00:00
|
|
|
$current_color = ++$current_color % $num_colors;
|
|
|
|
}
|
|
|
|
print "<tr class=\"$rev_color[$current_color]\">\n";
|
2006-10-05 20:55:58 +00:00
|
|
|
if ($group_size) {
|
|
|
|
print "<td class=\"sha1\"";
|
2006-10-30 20:37:54 +00:00
|
|
|
print " title=\"". esc_html($author) . ", $date\"";
|
2006-10-05 20:55:58 +00:00
|
|
|
print " rowspan=\"$group_size\"" if ($group_size > 1);
|
|
|
|
print ">";
|
|
|
|
print $cgi->a({-href => href(action=>"commit",
|
|
|
|
hash=>$full_rev,
|
|
|
|
file_name=>$file_name)},
|
2006-10-04 07:12:17 +00:00
|
|
|
esc_html($rev));
|
2006-10-05 20:55:58 +00:00
|
|
|
print "</td>\n";
|
2006-10-04 07:12:17 +00:00
|
|
|
}
|
2007-01-05 02:37:45 +00:00
|
|
|
open (my $dd, "-|", git_cmd(), "rev-parse", "$full_rev^")
|
|
|
|
or die_error("could not open git-rev-parse");
|
|
|
|
my $parent_commit = <$dd>;
|
|
|
|
close $dd;
|
|
|
|
chomp($parent_commit);
|
2006-10-05 20:55:58 +00:00
|
|
|
my $blamed = href(action => 'blame',
|
|
|
|
file_name => $meta->{'filename'},
|
2007-01-05 02:37:45 +00:00
|
|
|
hash_base => $parent_commit);
|
2006-10-05 20:55:58 +00:00
|
|
|
print "<td class=\"linenr\">";
|
|
|
|
print $cgi->a({ -href => "$blamed#l$orig_lineno",
|
|
|
|
-id => "l$lineno",
|
|
|
|
-class => "linenr" },
|
|
|
|
esc_html($lineno));
|
|
|
|
print "</td>";
|
2006-07-23 20:34:55 +00:00
|
|
|
print "<td class=\"pre\">" . esc_html($data) . "</td>\n";
|
|
|
|
print "</tr>\n";
|
|
|
|
}
|
|
|
|
print "</table>\n";
|
|
|
|
print "</div>";
|
2006-08-22 14:52:50 +00:00
|
|
|
close $fd
|
|
|
|
or print "Reading blob failed\n";
|
2006-07-23 20:34:55 +00:00
|
|
|
git_footer_html();
|
|
|
|
}
|
|
|
|
|
2006-06-11 15:45:19 +00:00
|
|
|
sub git_blame {
|
|
|
|
my $fd;
|
2006-08-20 06:23:04 +00:00
|
|
|
|
2006-09-01 03:43:32 +00:00
|
|
|
my ($have_blame) = gitweb_check_feature('blame');
|
|
|
|
if (!$have_blame) {
|
2006-08-20 06:23:04 +00:00
|
|
|
die_error('403 Permission denied', "Permission denied");
|
|
|
|
}
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error('404 Not Found', "File name not defined") if (!$file_name);
|
2006-08-14 00:05:47 +00:00
|
|
|
$hash_base ||= git_get_head_hash($project);
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Couldn't find base commit") unless ($hash_base);
|
2006-08-14 00:05:47 +00:00
|
|
|
my %co = parse_commit($hash_base)
|
2006-08-05 11:13:53 +00:00
|
|
|
or die_error(undef, "Reading commit failed");
|
2006-06-11 15:45:19 +00:00
|
|
|
if (!defined $hash) {
|
|
|
|
$hash = git_get_hash_by_path($hash_base, $file_name, "blob")
|
2006-08-05 11:13:53 +00:00
|
|
|
or die_error(undef, "Error lookup file");
|
2006-06-11 15:45:19 +00:00
|
|
|
}
|
2006-08-28 15:49:58 +00:00
|
|
|
open ($fd, "-|", git_cmd(), "annotate", '-l', '-t', '-r', $file_name, $hash_base)
|
2006-08-05 11:13:53 +00:00
|
|
|
or die_error(undef, "Open git-annotate failed");
|
2006-06-11 15:45:19 +00:00
|
|
|
git_header_html();
|
2006-07-30 13:01:07 +00:00
|
|
|
my $formats_nav =
|
2006-08-22 14:52:50 +00:00
|
|
|
$cgi->a({-href => href(action=>"blob", hash=>$hash, hash_base=>$hash_base, file_name=>$file_name)},
|
|
|
|
"blob") .
|
|
|
|
" | " .
|
2006-09-22 01:19:41 +00:00
|
|
|
$cgi->a({-href => href(action=>"history", hash=>$hash, hash_base=>$hash_base, file_name=>$file_name)},
|
|
|
|
"history") .
|
|
|
|
" | " .
|
2006-08-22 14:52:50 +00:00
|
|
|
$cgi->a({-href => href(action=>"blame", file_name=>$file_name)},
|
2006-09-22 01:19:53 +00:00
|
|
|
"HEAD");
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
|
|
|
|
git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
|
2006-08-17 17:39:29 +00:00
|
|
|
git_print_page_path($file_name, 'blob', $hash_base);
|
2006-06-11 15:45:19 +00:00
|
|
|
print "<div class=\"page_body\">\n";
|
|
|
|
print <<HTML;
|
2006-06-20 14:58:12 +00:00
|
|
|
<table class="blame">
|
2006-06-11 15:45:19 +00:00
|
|
|
<tr>
|
|
|
|
<th>Commit</th>
|
|
|
|
<th>Age</th>
|
|
|
|
<th>Author</th>
|
|
|
|
<th>Line</th>
|
|
|
|
<th>Data</th>
|
|
|
|
</tr>
|
|
|
|
HTML
|
|
|
|
my @line_class = (qw(light dark));
|
|
|
|
my $line_class_len = scalar (@line_class);
|
|
|
|
my $line_class_num = $#line_class;
|
|
|
|
while (my $line = <$fd>) {
|
|
|
|
my $long_rev;
|
|
|
|
my $short_rev;
|
|
|
|
my $author;
|
|
|
|
my $time;
|
|
|
|
my $lineno;
|
|
|
|
my $data;
|
|
|
|
my $age;
|
|
|
|
my $age_str;
|
2006-06-20 14:58:12 +00:00
|
|
|
my $age_class;
|
2006-06-11 15:45:19 +00:00
|
|
|
|
|
|
|
chomp $line;
|
|
|
|
$line_class_num = ($line_class_num + 1) % $line_class_len;
|
|
|
|
|
2006-08-26 00:13:05 +00:00
|
|
|
if ($line =~ m/^([0-9a-fA-F]{40})\t\(\s*([^\t]+)\t(\d+) [+-]\d\d\d\d\t(\d+)\)(.*)$/) {
|
2006-06-11 15:45:19 +00:00
|
|
|
$long_rev = $1;
|
|
|
|
$author = $2;
|
|
|
|
$time = $3;
|
|
|
|
$lineno = $4;
|
|
|
|
$data = $5;
|
|
|
|
} else {
|
2006-06-20 14:58:12 +00:00
|
|
|
print qq( <tr><td colspan="5" class="error">Unable to parse: $line</td></tr>\n);
|
2006-06-11 15:45:19 +00:00
|
|
|
next;
|
|
|
|
}
|
|
|
|
$short_rev = substr ($long_rev, 0, 8);
|
|
|
|
$age = time () - $time;
|
|
|
|
$age_str = age_string ($age);
|
|
|
|
$age_str =~ s/ / /g;
|
2006-06-20 14:58:12 +00:00
|
|
|
$age_class = age_class($age);
|
2006-06-11 15:45:19 +00:00
|
|
|
$author = esc_html ($author);
|
|
|
|
$author =~ s/ / /g;
|
2006-08-06 00:08:31 +00:00
|
|
|
|
|
|
|
$data = untabify($data);
|
2006-07-31 19:22:15 +00:00
|
|
|
$data = esc_html ($data);
|
2006-06-17 22:01:06 +00:00
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
print <<HTML;
|
|
|
|
<tr class="$line_class[$line_class_num]">
|
2006-08-15 22:24:30 +00:00
|
|
|
<td class="sha1"><a href="${\href (action=>"commit", hash=>$long_rev)}" class="text">$short_rev..</a></td>
|
2006-07-31 19:22:15 +00:00
|
|
|
<td class="$age_class">$age_str</td>
|
|
|
|
<td>$author</td>
|
|
|
|
<td class="linenr"><a id="$lineno" href="#$lineno" class="linenr">$lineno</a></td>
|
|
|
|
<td class="pre">$data</td>
|
|
|
|
</tr>
|
|
|
|
HTML
|
|
|
|
} # while (my $line = <$fd>)
|
|
|
|
print "</table>\n\n";
|
2006-08-22 14:52:50 +00:00
|
|
|
close $fd
|
|
|
|
or print "Reading blob failed.\n";
|
2006-07-31 19:22:15 +00:00
|
|
|
print "</div>";
|
|
|
|
git_footer_html();
|
2006-06-17 22:01:06 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
sub git_tags {
|
2006-08-14 00:05:47 +00:00
|
|
|
my $head = git_get_head_hash($project);
|
2006-07-31 19:22:15 +00:00
|
|
|
git_header_html();
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_page_nav('','', $head,undef,$head);
|
|
|
|
git_print_header_div('summary', $project);
|
2006-06-17 22:01:06 +00:00
|
|
|
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
my @tagslist = git_get_tags_list();
|
|
|
|
if (@tagslist) {
|
|
|
|
git_tags_body(\@tagslist);
|
2006-06-17 22:01:06 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
git_footer_html();
|
2006-06-17 22:01:06 +00:00
|
|
|
}
|
|
|
|
|
2006-07-31 19:22:15 +00:00
|
|
|
sub git_heads {
|
2006-08-14 00:05:47 +00:00
|
|
|
my $head = git_get_head_hash($project);
|
2006-07-31 19:22:15 +00:00
|
|
|
git_header_html();
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_page_nav('','', $head,undef,$head);
|
|
|
|
git_print_header_div('summary', $project);
|
2006-07-10 03:18:57 +00:00
|
|
|
|
gitweb: Use git-for-each-ref to generate list of heads and/or tags
Add two subroutines: git_get_heads_list and git_get_refs_list, which
fill out needed parts of refs info (heads and tags respectively) info
using single call to git-for-each-ref, instead of using
git-peek-remote to get list of references and using parse_ref for each
ref to get ref info, which in turn uses at least one call of git
command.
Replace call to git_get_refs_list in git_summary by call to
git_get_references, git_get_heads_list and git_get_tags_list
(simplifying this subroutine a bit). Use git_get_heads_list in
git_heads and git_get_tags_list in git_tags. Modify git_tags_body
slightly to accept output from git_get_tags_list.
Remove no longer used, and a bit hackish, git_get_refs_list.
parse_ref is no longer used, but is left for now.
Generating "summary" and "tags" views should be much faster for
projects which have large number of tags.
CHANGES IN OUTPUT: Before, if ref in refs/tags was tag pointing to
commit we used committer epoch as epoch for ref, and used tagger epoch
as epoch only for tag pointing to object of other type. If ref in
refs/tags was commit, we used committer epoch as epoch for ref (see
parse_ref; we sorted in gitweb by 'epoch' field).
Currently we use committer epoch for refs pointing to commit objects,
and tagger epoch for refs pointing to tag object, even if tag points
to commit.
Simple ab benchmark before and after this patch for my git.git
repository (git/jnareb-git.git) with some heads and tags added
as compared to git.git repository, shows around 2.4-3.0 times speedup
for "summary" and "tags" views:
summary 3134 +/- 24.2 ms --> 1081 +/- 30.2 ms
tags 2886 +/- 18.9 ms --> 1196 +/- 15.6 ms
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-02 19:23:11 +00:00
|
|
|
my @headslist = git_get_heads_list();
|
|
|
|
if (@headslist) {
|
|
|
|
git_heads_body(\@headslist, $head);
|
2006-06-17 11:32:15 +00:00
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
git_footer_html();
|
2006-06-17 11:32:15 +00:00
|
|
|
}
|
|
|
|
|
2005-08-07 18:26:27 +00:00
|
|
|
sub git_blob_plain {
|
2006-08-26 17:14:25 +00:00
|
|
|
my $expires;
|
|
|
|
|
2006-07-23 20:28:55 +00:00
|
|
|
if (!defined $hash) {
|
2006-07-29 20:43:40 +00:00
|
|
|
if (defined $file_name) {
|
2006-08-14 00:05:47 +00:00
|
|
|
my $base = $hash_base || git_get_head_hash($project);
|
2006-07-29 20:43:40 +00:00
|
|
|
$hash = git_get_hash_by_path($base, $file_name, "blob")
|
2006-08-05 11:13:53 +00:00
|
|
|
or die_error(undef, "Error lookup file");
|
2006-07-29 20:43:40 +00:00
|
|
|
} else {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "No file name defined");
|
2006-07-29 20:43:40 +00:00
|
|
|
}
|
2006-09-16 21:09:02 +00:00
|
|
|
} elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
|
|
|
|
# blobs defined by non-textual hash id's can be cached
|
|
|
|
$expires = "+1d";
|
2006-07-29 20:43:40 +00:00
|
|
|
}
|
2006-09-16 21:09:02 +00:00
|
|
|
|
2006-07-10 03:18:57 +00:00
|
|
|
my $type = shift;
|
2006-08-28 15:49:58 +00:00
|
|
|
open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
|
2006-08-05 10:56:04 +00:00
|
|
|
or die_error(undef, "Couldn't cat $file_name, $hash");
|
2006-07-10 03:18:57 +00:00
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
$type ||= blob_mimetype($fd, $file_name);
|
2006-06-17 11:32:15 +00:00
|
|
|
|
|
|
|
# save as filename, even when no $file_name is given
|
|
|
|
my $save_as = "$hash";
|
2005-10-17 01:27:54 +00:00
|
|
|
if (defined $file_name) {
|
|
|
|
$save_as = $file_name;
|
2006-06-17 11:32:15 +00:00
|
|
|
} elsif ($type =~ m/^text\//) {
|
|
|
|
$save_as .= '.txt';
|
2005-10-17 01:27:54 +00:00
|
|
|
}
|
2006-06-17 11:32:15 +00:00
|
|
|
|
2006-08-26 17:14:25 +00:00
|
|
|
print $cgi->header(
|
|
|
|
-type => "$type",
|
|
|
|
-expires=>$expires,
|
2006-09-28 23:51:43 +00:00
|
|
|
-content_disposition => 'inline; filename="' . "$save_as" . '"');
|
2005-08-07 18:26:27 +00:00
|
|
|
undef $/;
|
2006-06-17 16:07:24 +00:00
|
|
|
binmode STDOUT, ':raw';
|
2005-08-07 18:26:27 +00:00
|
|
|
print <$fd>;
|
2006-06-17 16:07:24 +00:00
|
|
|
binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
|
2005-08-07 18:26:27 +00:00
|
|
|
$/ = "\n";
|
|
|
|
close $fd;
|
|
|
|
}
|
|
|
|
|
2006-07-10 03:18:57 +00:00
|
|
|
sub git_blob {
|
2006-08-26 17:14:25 +00:00
|
|
|
my $expires;
|
|
|
|
|
2006-07-23 20:28:55 +00:00
|
|
|
if (!defined $hash) {
|
2006-07-29 20:43:40 +00:00
|
|
|
if (defined $file_name) {
|
2006-08-14 00:05:47 +00:00
|
|
|
my $base = $hash_base || git_get_head_hash($project);
|
2006-07-29 20:43:40 +00:00
|
|
|
$hash = git_get_hash_by_path($base, $file_name, "blob")
|
2006-08-05 11:13:53 +00:00
|
|
|
or die_error(undef, "Error lookup file");
|
2006-07-29 20:43:40 +00:00
|
|
|
} else {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "No file name defined");
|
2006-07-29 20:43:40 +00:00
|
|
|
}
|
2006-09-16 21:09:02 +00:00
|
|
|
} elsif ($hash =~ m/^[0-9a-fA-F]{40}$/) {
|
|
|
|
# blobs defined by non-textual hash id's can be cached
|
|
|
|
$expires = "+1d";
|
2006-07-29 20:43:40 +00:00
|
|
|
}
|
2006-09-16 21:09:02 +00:00
|
|
|
|
2006-09-01 03:43:32 +00:00
|
|
|
my ($have_blame) = gitweb_check_feature('blame');
|
2006-08-28 15:49:58 +00:00
|
|
|
open my $fd, "-|", git_cmd(), "cat-file", "blob", $hash
|
2006-08-05 11:13:53 +00:00
|
|
|
or die_error(undef, "Couldn't cat $file_name, $hash");
|
2006-08-14 00:05:47 +00:00
|
|
|
my $mimetype = blob_mimetype($fd, $file_name);
|
gitweb: Allow PNG, GIF, JPEG images to be displayed in "blob" view
Allow images in one of web formats (PNG, GIF, JPEG) - actually files
with mimetype of image/png, image/git, image/jpeg - to be displayed in
"blob" view using <img /> element, instead of using "blob_plain" view
for them, like for all other files except also text/* mimetype files.
This makes possible to easily go to file history, to HEAD version of
the file, to appropriate commit etc; all of those are not available
in "blob_plain" (raw) view.
Only text files can have "blame" view link in the formats part of
navbar.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-12-04 22:47:22 +00:00
|
|
|
if ($mimetype !~ m!^(?:text/|image/(?:gif|png|jpeg)$)!) {
|
2006-07-10 03:18:57 +00:00
|
|
|
close $fd;
|
|
|
|
return git_blob_plain($mimetype);
|
|
|
|
}
|
gitweb: Allow PNG, GIF, JPEG images to be displayed in "blob" view
Allow images in one of web formats (PNG, GIF, JPEG) - actually files
with mimetype of image/png, image/git, image/jpeg - to be displayed in
"blob" view using <img /> element, instead of using "blob_plain" view
for them, like for all other files except also text/* mimetype files.
This makes possible to easily go to file history, to HEAD version of
the file, to appropriate commit etc; all of those are not available
in "blob_plain" (raw) view.
Only text files can have "blame" view link in the formats part of
navbar.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-12-04 22:47:22 +00:00
|
|
|
# we can have blame only for text/* mimetype
|
|
|
|
$have_blame &&= ($mimetype =~ m!^text/!);
|
|
|
|
|
2006-08-26 17:14:25 +00:00
|
|
|
git_header_html(undef, $expires);
|
2006-07-30 13:01:07 +00:00
|
|
|
my $formats_nav = '';
|
2006-08-14 00:05:47 +00:00
|
|
|
if (defined $hash_base && (my %co = parse_commit($hash_base))) {
|
2006-07-10 03:18:57 +00:00
|
|
|
if (defined $file_name) {
|
|
|
|
if ($have_blame) {
|
2006-08-22 14:52:50 +00:00
|
|
|
$formats_nav .=
|
|
|
|
$cgi->a({-href => href(action=>"blame", hash_base=>$hash_base,
|
|
|
|
hash=>$hash, file_name=>$file_name)},
|
|
|
|
"blame") .
|
|
|
|
" | ";
|
2006-07-10 03:18:57 +00:00
|
|
|
}
|
2006-07-30 13:01:07 +00:00
|
|
|
$formats_nav .=
|
2006-09-22 01:19:41 +00:00
|
|
|
$cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
|
|
|
|
hash=>$hash, file_name=>$file_name)},
|
|
|
|
"history") .
|
|
|
|
" | " .
|
2006-08-22 14:52:50 +00:00
|
|
|
$cgi->a({-href => href(action=>"blob_plain",
|
|
|
|
hash=>$hash, file_name=>$file_name)},
|
2006-09-22 01:19:50 +00:00
|
|
|
"raw") .
|
2006-08-22 14:52:50 +00:00
|
|
|
" | " .
|
|
|
|
$cgi->a({-href => href(action=>"blob",
|
|
|
|
hash_base=>"HEAD", file_name=>$file_name)},
|
2006-09-22 01:19:53 +00:00
|
|
|
"HEAD");
|
2006-07-10 03:18:57 +00:00
|
|
|
} else {
|
2006-08-22 14:52:50 +00:00
|
|
|
$formats_nav .=
|
2006-09-22 01:19:50 +00:00
|
|
|
$cgi->a({-href => href(action=>"blob_plain", hash=>$hash)}, "raw");
|
2006-07-10 03:18:57 +00:00
|
|
|
}
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
|
|
|
|
git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
|
2006-07-10 03:18:57 +00:00
|
|
|
} else {
|
|
|
|
print "<div class=\"page_nav\">\n" .
|
|
|
|
"<br/><br/></div>\n" .
|
|
|
|
"<div class=\"title\">$hash</div>\n";
|
|
|
|
}
|
2006-08-17 17:39:29 +00:00
|
|
|
git_print_page_path($file_name, "blob", $hash_base);
|
2006-07-10 03:18:57 +00:00
|
|
|
print "<div class=\"page_body\">\n";
|
gitweb: Allow PNG, GIF, JPEG images to be displayed in "blob" view
Allow images in one of web formats (PNG, GIF, JPEG) - actually files
with mimetype of image/png, image/git, image/jpeg - to be displayed in
"blob" view using <img /> element, instead of using "blob_plain" view
for them, like for all other files except also text/* mimetype files.
This makes possible to easily go to file history, to HEAD version of
the file, to appropriate commit etc; all of those are not available
in "blob_plain" (raw) view.
Only text files can have "blame" view link in the formats part of
navbar.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-12-04 22:47:22 +00:00
|
|
|
if ($mimetype =~ m!^text/!) {
|
|
|
|
my $nr;
|
|
|
|
while (my $line = <$fd>) {
|
|
|
|
chomp $line;
|
|
|
|
$nr++;
|
|
|
|
$line = untabify($line);
|
|
|
|
printf "<div class=\"pre\"><a id=\"l%i\" href=\"#l%i\" class=\"linenr\">%4i</a> %s</div>\n",
|
|
|
|
$nr, $nr, $nr, esc_html($line, -nbsp=>1);
|
|
|
|
}
|
|
|
|
} elsif ($mimetype =~ m!^image/!) {
|
|
|
|
print qq!<img type="$mimetype"!;
|
|
|
|
if ($file_name) {
|
|
|
|
print qq! alt="$file_name" title="$file_name"!;
|
|
|
|
}
|
|
|
|
print qq! src="! .
|
|
|
|
href(action=>"blob_plain", hash=>$hash,
|
|
|
|
hash_base=>$hash_base, file_name=>$file_name) .
|
|
|
|
qq!" />\n!;
|
2006-07-10 03:18:57 +00:00
|
|
|
}
|
2006-08-22 14:52:50 +00:00
|
|
|
close $fd
|
|
|
|
or print "Reading blob failed.\n";
|
2006-07-10 03:18:57 +00:00
|
|
|
print "</div>";
|
|
|
|
git_footer_html();
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:21:23 +00:00
|
|
|
sub git_tree {
|
2006-09-28 23:49:21 +00:00
|
|
|
my $have_snapshot = gitweb_have_snapshot();
|
2006-09-22 01:19:41 +00:00
|
|
|
|
2006-09-29 16:57:43 +00:00
|
|
|
if (!defined $hash_base) {
|
|
|
|
$hash_base = "HEAD";
|
|
|
|
}
|
2005-08-07 18:21:04 +00:00
|
|
|
if (!defined $hash) {
|
2005-08-07 18:21:23 +00:00
|
|
|
if (defined $file_name) {
|
2006-09-29 16:57:43 +00:00
|
|
|
$hash = git_get_hash_by_path($hash_base, $file_name, "tree");
|
|
|
|
} else {
|
|
|
|
$hash = $hash_base;
|
2005-08-07 18:25:27 +00:00
|
|
|
}
|
2005-08-07 18:23:35 +00:00
|
|
|
}
|
2005-11-24 15:56:55 +00:00
|
|
|
$/ = "\0";
|
2006-08-28 15:49:58 +00:00
|
|
|
open my $fd, "-|", git_cmd(), "ls-tree", '-z', $hash
|
2006-08-05 11:13:53 +00:00
|
|
|
or die_error(undef, "Open git-ls-tree failed");
|
2006-07-30 12:58:11 +00:00
|
|
|
my @entries = map { chomp; $_ } <$fd>;
|
2006-08-05 11:13:53 +00:00
|
|
|
close $fd or die_error(undef, "Reading tree failed");
|
2005-11-24 15:56:55 +00:00
|
|
|
$/ = "\n";
|
2005-08-07 18:18:13 +00:00
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
my $refs = git_get_references();
|
|
|
|
my $ref = format_ref_marker($refs, $hash_base);
|
2005-08-07 18:02:47 +00:00
|
|
|
git_header_html();
|
2006-10-21 15:53:09 +00:00
|
|
|
my $basedir = '';
|
2006-09-01 03:43:32 +00:00
|
|
|
my ($have_blame) = gitweb_check_feature('blame');
|
2006-08-14 00:05:47 +00:00
|
|
|
if (defined $hash_base && (my %co = parse_commit($hash_base))) {
|
2006-09-22 01:19:41 +00:00
|
|
|
my @views_nav = ();
|
|
|
|
if (defined $file_name) {
|
|
|
|
push @views_nav,
|
|
|
|
$cgi->a({-href => href(action=>"history", hash_base=>$hash_base,
|
|
|
|
hash=>$hash, file_name=>$file_name)},
|
|
|
|
"history"),
|
|
|
|
$cgi->a({-href => href(action=>"tree",
|
|
|
|
hash_base=>"HEAD", file_name=>$file_name)},
|
2006-09-22 01:19:53 +00:00
|
|
|
"HEAD"),
|
2006-09-22 01:19:41 +00:00
|
|
|
}
|
|
|
|
if ($have_snapshot) {
|
|
|
|
# FIXME: Should be available when we have no hash base as well.
|
|
|
|
push @views_nav,
|
2006-09-22 23:21:20 +00:00
|
|
|
$cgi->a({-href => href(action=>"snapshot", hash=>$hash)},
|
2006-10-21 15:52:19 +00:00
|
|
|
"snapshot");
|
2006-09-22 01:19:41 +00:00
|
|
|
}
|
|
|
|
git_print_page_nav('tree','', $hash_base, undef, undef, join(' | ', @views_nav));
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash_base);
|
2005-08-07 18:18:13 +00:00
|
|
|
} else {
|
2006-08-30 22:35:07 +00:00
|
|
|
undef $hash_base;
|
2005-08-07 18:18:13 +00:00
|
|
|
print "<div class=\"page_nav\">\n";
|
|
|
|
print "<br/><br/></div>\n";
|
|
|
|
print "<div class=\"title\">$hash</div>\n";
|
|
|
|
}
|
2005-08-07 18:21:23 +00:00
|
|
|
if (defined $file_name) {
|
2006-10-21 15:53:09 +00:00
|
|
|
$basedir = $file_name;
|
|
|
|
if ($basedir ne '' && substr($basedir, -1) ne '/') {
|
|
|
|
$basedir .= '/';
|
|
|
|
}
|
2005-08-07 18:21:23 +00:00
|
|
|
}
|
2006-08-17 17:39:29 +00:00
|
|
|
git_print_page_path($file_name, 'tree', $hash_base);
|
2005-08-07 18:12:11 +00:00
|
|
|
print "<div class=\"page_body\">\n";
|
2005-08-07 18:21:46 +00:00
|
|
|
print "<table cellspacing=\"0\">\n";
|
gitweb: "alternate" starts with shade (i.e. 1)
When displaying a list of rows (difftree, shortlog, etc),
the first entry is now printed shaded, i.e. alternate is
initialized to 1, as opposed to non-shaded (alternate
initialized to 0).
This solves the problem when there is only one row to
display -- it is displayed shaded to visually indicate that
it is "active", part of a "list", etc.
(Compare this to the trivial case of more than one entry,
where the rows have alternating shade, thus suggesting
being part of a "list" of "active" entries, etc.)
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-28 23:47:50 +00:00
|
|
|
my $alternate = 1;
|
2006-10-21 15:54:44 +00:00
|
|
|
# '..' (top directory) link if possible
|
|
|
|
if (defined $hash_base &&
|
|
|
|
defined $file_name && $file_name =~ m![^/]+$!) {
|
|
|
|
if ($alternate) {
|
|
|
|
print "<tr class=\"dark\">\n";
|
|
|
|
} else {
|
|
|
|
print "<tr class=\"light\">\n";
|
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
|
|
|
|
|
|
|
my $up = $file_name;
|
|
|
|
$up =~ s!/?[^/]+$!!;
|
|
|
|
undef $up unless $up;
|
|
|
|
# based on git_print_tree_entry
|
|
|
|
print '<td class="mode">' . mode_str('040000') . "</td>\n";
|
|
|
|
print '<td class="list">';
|
|
|
|
print $cgi->a({-href => href(action=>"tree", hash_base=>$hash_base,
|
|
|
|
file_name=>$up)},
|
|
|
|
"..");
|
|
|
|
print "</td>\n";
|
|
|
|
print "<td class=\"link\"></td>\n";
|
|
|
|
|
|
|
|
print "</tr>\n";
|
|
|
|
}
|
2005-08-07 17:49:46 +00:00
|
|
|
foreach my $line (@entries) {
|
2006-08-30 22:32:15 +00:00
|
|
|
my %t = parse_ls_tree_line($line, -z => 1);
|
|
|
|
|
2005-08-07 18:25:42 +00:00
|
|
|
if ($alternate) {
|
2005-08-07 18:27:18 +00:00
|
|
|
print "<tr class=\"dark\">\n";
|
2005-08-07 18:25:42 +00:00
|
|
|
} else {
|
2005-08-07 18:27:18 +00:00
|
|
|
print "<tr class=\"light\">\n";
|
2005-08-07 18:25:42 +00:00
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
2006-08-30 22:32:15 +00:00
|
|
|
|
2006-10-21 15:53:09 +00:00
|
|
|
git_print_tree_entry(\%t, $basedir, $hash_base, $have_blame);
|
2006-08-30 22:35:07 +00:00
|
|
|
|
2005-08-07 18:21:46 +00:00
|
|
|
print "</tr>\n";
|
2005-08-07 17:49:46 +00:00
|
|
|
}
|
2005-08-07 18:21:46 +00:00
|
|
|
print "</table>\n" .
|
|
|
|
"</div>";
|
2005-08-07 18:02:47 +00:00
|
|
|
git_footer_html();
|
2005-08-07 18:21:23 +00:00
|
|
|
}
|
|
|
|
|
2006-08-17 15:29:46 +00:00
|
|
|
sub git_snapshot {
|
2006-08-20 06:23:04 +00:00
|
|
|
my ($ctype, $suffix, $command) = gitweb_check_feature('snapshot');
|
|
|
|
my $have_snapshot = (defined $ctype && defined $suffix);
|
|
|
|
if (!$have_snapshot) {
|
|
|
|
die_error('403 Permission denied', "Permission denied");
|
|
|
|
}
|
|
|
|
|
2006-08-17 15:29:46 +00:00
|
|
|
if (!defined $hash) {
|
|
|
|
$hash = git_get_head_hash($project);
|
|
|
|
}
|
|
|
|
|
2007-01-30 10:23:38 +00:00
|
|
|
my $filename = to_utf8(basename($project)) . "-$hash.tar.$suffix";
|
2006-08-17 15:29:46 +00:00
|
|
|
|
2006-09-25 23:59:43 +00:00
|
|
|
print $cgi->header(
|
2006-12-11 17:09:58 +00:00
|
|
|
-type => "application/$ctype",
|
2006-09-28 23:51:43 +00:00
|
|
|
-content_disposition => 'inline; filename="' . "$filename" . '"',
|
2006-09-25 23:59:43 +00:00
|
|
|
-status => '200 OK');
|
2006-08-17 15:29:46 +00:00
|
|
|
|
2006-10-05 09:26:12 +00:00
|
|
|
my $git = git_cmd_str();
|
|
|
|
my $name = $project;
|
|
|
|
$name =~ s/\047/\047\\\047\047/g;
|
|
|
|
open my $fd, "-|",
|
|
|
|
"$git archive --format=tar --prefix=\'$name\'/ $hash | $command"
|
|
|
|
or die_error(undef, "Execute git-tar-tree failed.");
|
2006-08-17 15:29:46 +00:00
|
|
|
binmode STDOUT, ':raw';
|
|
|
|
print <$fd>;
|
|
|
|
binmode STDOUT, ':utf8'; # as set at the beginning of gitweb.cgi
|
|
|
|
close $fd;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:21:23 +00:00
|
|
|
sub git_log {
|
2006-08-14 00:05:47 +00:00
|
|
|
my $head = git_get_head_hash($project);
|
2005-08-07 18:24:35 +00:00
|
|
|
if (!defined $hash) {
|
2005-08-07 18:26:27 +00:00
|
|
|
$hash = $head;
|
2005-08-07 18:24:35 +00:00
|
|
|
}
|
2005-08-07 18:26:49 +00:00
|
|
|
if (!defined $page) {
|
|
|
|
$page = 0;
|
2005-08-07 18:21:04 +00:00
|
|
|
}
|
2006-08-14 00:05:47 +00:00
|
|
|
my $refs = git_get_references();
|
2005-08-07 18:26:49 +00:00
|
|
|
|
2006-12-24 14:31:45 +00:00
|
|
|
my @commitlist = parse_commits($hash, 101, (100 * $page));
|
2005-08-07 18:26:49 +00:00
|
|
|
|
2006-12-24 14:31:45 +00:00
|
|
|
my $paging_nav = format_paging_nav('log', $hash, $head, $page, (100 * ($page+1)));
|
2006-07-30 13:01:07 +00:00
|
|
|
|
|
|
|
git_header_html();
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_page_nav('log','', $hash,undef,undef, $paging_nav);
|
2006-07-30 13:01:07 +00:00
|
|
|
|
2006-12-24 14:31:45 +00:00
|
|
|
if (!@commitlist) {
|
2006-08-14 00:05:47 +00:00
|
|
|
my %co = parse_commit($hash);
|
2006-07-30 18:32:01 +00:00
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_header_div('summary', $project);
|
2005-08-07 18:23:35 +00:00
|
|
|
print "<div class=\"page_body\"> Last change $co{'age_string'}.<br/><br/></div>\n";
|
2005-08-07 17:49:46 +00:00
|
|
|
}
|
2006-12-24 14:31:45 +00:00
|
|
|
my $to = ($#commitlist >= 99) ? (99) : ($#commitlist);
|
|
|
|
for (my $i = 0; $i <= $to; $i++) {
|
|
|
|
my %co = %{$commitlist[$i]};
|
2005-08-07 18:21:04 +00:00
|
|
|
next if !%co;
|
2006-12-24 14:31:45 +00:00
|
|
|
my $commit = $co{'id'};
|
|
|
|
my $ref = format_ref_marker($refs, $commit);
|
2006-08-14 00:05:47 +00:00
|
|
|
my %ad = parse_date($co{'author_epoch'});
|
|
|
|
git_print_header_div('commit',
|
2006-08-10 10:38:47 +00:00
|
|
|
"<span class=\"age\">$co{'age_string'}</span>" .
|
|
|
|
esc_html($co{'title'}) . $ref,
|
|
|
|
$commit);
|
2005-08-07 18:20:07 +00:00
|
|
|
print "<div class=\"title_text\">\n" .
|
|
|
|
"<div class=\"log_link\">\n" .
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(action=>"commit", hash=>$commit)}, "commit") .
|
2006-08-22 14:52:50 +00:00
|
|
|
" | " .
|
|
|
|
$cgi->a({-href => href(action=>"commitdiff", hash=>$commit)}, "commitdiff") .
|
2006-09-22 01:19:48 +00:00
|
|
|
" | " .
|
2006-09-22 23:56:43 +00:00
|
|
|
$cgi->a({-href => href(action=>"tree", hash=>$commit, hash_base=>$commit)}, "tree") .
|
2005-08-07 18:21:34 +00:00
|
|
|
"<br/>\n" .
|
2005-08-07 18:20:07 +00:00
|
|
|
"</div>\n" .
|
replace invalid utf8 sequences by UTF-8 REPLACEMENT CHARACTER (efbfbd)
I still strongly disagree with the git maintainers not to hint people,
to use the only sane default encoding for a distributed project,
which is utf8. I'm tired of hearing filesystem development arguments.
Git is a software offered to merge forth and back across the world
and not to provide a content neutral filesystem.
Btw: I have nothing against the ability to run git in a closed environment,
with a different encoding, that's fine, sure. But that is obviously not
the case for the projects on kernel.org. It's about sane defaults,
nothing else.
You have to make decisions guy, as always in life. The problems to
allow random encoded garbage in commit messages _without_ storing
the encoding, just makes zero sense. Eighter you introduce a per-commit
encoding field, if you insist on this craziness, or you define a default
encoding. Everything else is just lazy and does not solve any problem,
besides that you can claim now, that you are not responsible for the mess
in the repository.
Gitweb shows several commits at once, you allow various encodings committed
to the same repository, without any hint what that garbage from the
individual commits is encoded with. No idea why you don't get
the problem - it's unsolvable. If you merge different peoples work, you
have to speak a common language!
Kay Sievers <kay.sievers@vrfy.org>
2005-11-19 16:41:29 +00:00
|
|
|
"<i>" . esc_html($co{'author_name'}) . " [$ad{'rfc2822'}]</i><br/>\n" .
|
2006-08-17 09:21:23 +00:00
|
|
|
"</div>\n";
|
|
|
|
|
|
|
|
print "<div class=\"log_body\">\n";
|
2006-10-24 11:52:46 +00:00
|
|
|
git_print_log($co{'comment'}, -final_empty_line=> 1);
|
2005-08-07 18:21:23 +00:00
|
|
|
print "</div>\n";
|
2006-12-24 14:31:45 +00:00
|
|
|
}
|
|
|
|
if ($#commitlist >= 100) {
|
|
|
|
print "<div class=\"page_nav\">\n";
|
|
|
|
print $cgi->a({-href => href(action=>"log", hash=>$hash, page=>$page+1),
|
|
|
|
-accesskey => "n", -title => "Alt-n"}, "next");
|
|
|
|
print "</div>\n";
|
2005-08-07 18:02:33 +00:00
|
|
|
}
|
2005-08-07 18:20:07 +00:00
|
|
|
git_footer_html();
|
2005-08-07 18:21:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sub git_commit {
|
2006-11-18 22:35:41 +00:00
|
|
|
$hash ||= $hash_base || "HEAD";
|
2006-08-14 00:05:47 +00:00
|
|
|
my %co = parse_commit($hash);
|
2005-08-07 18:20:07 +00:00
|
|
|
if (!%co) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Unknown commit object");
|
2005-08-07 18:18:13 +00:00
|
|
|
}
|
2006-08-14 00:05:47 +00:00
|
|
|
my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
|
|
|
|
my %cd = parse_date($co{'committer_epoch'}, $co{'committer_tz'});
|
2005-08-07 17:49:46 +00:00
|
|
|
|
2006-12-15 20:57:16 +00:00
|
|
|
my $parent = $co{'parent'};
|
|
|
|
my $parents = $co{'parents'}; # listref
|
|
|
|
|
|
|
|
# we need to prepare $formats_nav before any parameter munging
|
|
|
|
my $formats_nav;
|
|
|
|
if (!defined $parent) {
|
|
|
|
# --root commitdiff
|
|
|
|
$formats_nav .= '(initial)';
|
|
|
|
} elsif (@$parents == 1) {
|
|
|
|
# single parent commit
|
|
|
|
$formats_nav .=
|
|
|
|
'(parent: ' .
|
|
|
|
$cgi->a({-href => href(action=>"commit",
|
|
|
|
hash=>$parent)},
|
|
|
|
esc_html(substr($parent, 0, 7))) .
|
|
|
|
')';
|
|
|
|
} else {
|
|
|
|
# merge commit
|
|
|
|
$formats_nav .=
|
|
|
|
'(merge: ' .
|
|
|
|
join(' ', map {
|
|
|
|
$cgi->a({-href => href(action=>"commitdiff",
|
|
|
|
hash=>$_)},
|
|
|
|
esc_html(substr($_, 0, 7)));
|
|
|
|
} @$parents ) .
|
|
|
|
')';
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:28:53 +00:00
|
|
|
if (!defined $parent) {
|
gitweb: Use list for of open for running git commands, thorougly.
Use list form of open for running git commands and reading their
output through pipe, for example
open my $fd, "-|", $GIT, "rev-list", "--header", "--parents", $hash
instead of
open my $fd, "-|", "$GIT rev-list --header --parents $hash"
Single letter options use ' instead of " as quotes, according to style
used in list form of magic "-|" open.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-07-31 01:28:34 +00:00
|
|
|
$parent = "--root";
|
2005-08-07 18:19:56 +00:00
|
|
|
}
|
2006-12-15 16:53:45 +00:00
|
|
|
my @difftree;
|
|
|
|
if (@$parents <= 1) {
|
|
|
|
# difftree output is not printed for merges
|
|
|
|
open my $fd, "-|", git_cmd(), "diff-tree", '-r', "--no-commit-id",
|
|
|
|
@diff_opts, $parent, $hash, "--"
|
|
|
|
or die_error(undef, "Open git-diff-tree failed");
|
|
|
|
@difftree = map { chomp; $_ } <$fd>;
|
|
|
|
close $fd or die_error(undef, "Reading git-diff-tree failed");
|
|
|
|
}
|
2005-10-19 01:18:45 +00:00
|
|
|
|
|
|
|
# non-textual hash id's can be cached
|
|
|
|
my $expires;
|
|
|
|
if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
|
|
|
|
$expires = "+1d";
|
|
|
|
}
|
2006-08-14 00:05:47 +00:00
|
|
|
my $refs = git_get_references();
|
|
|
|
my $ref = format_ref_marker($refs, $co{'id'});
|
2006-08-20 06:23:04 +00:00
|
|
|
|
2006-09-28 23:49:21 +00:00
|
|
|
my $have_snapshot = gitweb_have_snapshot();
|
2006-08-20 06:23:04 +00:00
|
|
|
|
2006-07-31 00:21:52 +00:00
|
|
|
git_header_html(undef, $expires);
|
2006-10-06 16:59:33 +00:00
|
|
|
git_print_page_nav('commit', '',
|
2006-08-22 14:52:50 +00:00
|
|
|
$hash, $co{'tree'}, $hash,
|
2006-12-15 20:57:16 +00:00
|
|
|
$formats_nav);
|
2006-07-23 20:36:32 +00:00
|
|
|
|
2005-08-07 18:21:04 +00:00
|
|
|
if (defined $co{'parent'}) {
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_header_div('commitdiff', esc_html($co{'title'}) . $ref, $hash);
|
2005-08-07 18:21:04 +00:00
|
|
|
} else {
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_header_div('tree', esc_html($co{'title'}) . $ref, $co{'tree'}, $hash);
|
2005-08-07 18:21:04 +00:00
|
|
|
}
|
2005-08-07 18:19:56 +00:00
|
|
|
print "<div class=\"title_text\">\n" .
|
2005-08-07 18:21:04 +00:00
|
|
|
"<table cellspacing=\"0\">\n";
|
replace invalid utf8 sequences by UTF-8 REPLACEMENT CHARACTER (efbfbd)
I still strongly disagree with the git maintainers not to hint people,
to use the only sane default encoding for a distributed project,
which is utf8. I'm tired of hearing filesystem development arguments.
Git is a software offered to merge forth and back across the world
and not to provide a content neutral filesystem.
Btw: I have nothing against the ability to run git in a closed environment,
with a different encoding, that's fine, sure. But that is obviously not
the case for the projects on kernel.org. It's about sane defaults,
nothing else.
You have to make decisions guy, as always in life. The problems to
allow random encoded garbage in commit messages _without_ storing
the encoding, just makes zero sense. Eighter you introduce a per-commit
encoding field, if you insist on this craziness, or you define a default
encoding. Everything else is just lazy and does not solve any problem,
besides that you can claim now, that you are not responsible for the mess
in the repository.
Gitweb shows several commits at once, you allow various encodings committed
to the same repository, without any hint what that garbage from the
individual commits is encoded with. No idea why you don't get
the problem - it's unsolvable. If you merge different peoples work, you
have to speak a common language!
Kay Sievers <kay.sievers@vrfy.org>
2005-11-19 16:41:29 +00:00
|
|
|
print "<tr><td>author</td><td>" . esc_html($co{'author'}) . "</td></tr>\n".
|
2005-08-07 18:25:42 +00:00
|
|
|
"<tr>" .
|
|
|
|
"<td></td><td> $ad{'rfc2822'}";
|
2005-08-07 18:18:44 +00:00
|
|
|
if ($ad{'hour_local'} < 6) {
|
2006-08-22 14:52:50 +00:00
|
|
|
printf(" (<span class=\"atnight\">%02d:%02d</span> %s)",
|
|
|
|
$ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
|
2005-08-07 18:21:04 +00:00
|
|
|
} else {
|
2006-08-22 14:52:50 +00:00
|
|
|
printf(" (%02d:%02d %s)",
|
|
|
|
$ad{'hour_local'}, $ad{'minute_local'}, $ad{'tz_local'});
|
2005-08-07 18:21:04 +00:00
|
|
|
}
|
2005-08-07 18:25:42 +00:00
|
|
|
print "</td>" .
|
|
|
|
"</tr>\n";
|
replace invalid utf8 sequences by UTF-8 REPLACEMENT CHARACTER (efbfbd)
I still strongly disagree with the git maintainers not to hint people,
to use the only sane default encoding for a distributed project,
which is utf8. I'm tired of hearing filesystem development arguments.
Git is a software offered to merge forth and back across the world
and not to provide a content neutral filesystem.
Btw: I have nothing against the ability to run git in a closed environment,
with a different encoding, that's fine, sure. But that is obviously not
the case for the projects on kernel.org. It's about sane defaults,
nothing else.
You have to make decisions guy, as always in life. The problems to
allow random encoded garbage in commit messages _without_ storing
the encoding, just makes zero sense. Eighter you introduce a per-commit
encoding field, if you insist on this craziness, or you define a default
encoding. Everything else is just lazy and does not solve any problem,
besides that you can claim now, that you are not responsible for the mess
in the repository.
Gitweb shows several commits at once, you allow various encodings committed
to the same repository, without any hint what that garbage from the
individual commits is encoded with. No idea why you don't get
the problem - it's unsolvable. If you merge different peoples work, you
have to speak a common language!
Kay Sievers <kay.sievers@vrfy.org>
2005-11-19 16:41:29 +00:00
|
|
|
print "<tr><td>committer</td><td>" . esc_html($co{'committer'}) . "</td></tr>\n";
|
2006-08-22 14:52:50 +00:00
|
|
|
print "<tr><td></td><td> $cd{'rfc2822'}" .
|
|
|
|
sprintf(" (%02d:%02d %s)", $cd{'hour_local'}, $cd{'minute_local'}, $cd{'tz_local'}) .
|
|
|
|
"</td></tr>\n";
|
2006-06-20 14:58:12 +00:00
|
|
|
print "<tr><td>commit</td><td class=\"sha1\">$co{'id'}</td></tr>\n";
|
2005-08-07 18:25:42 +00:00
|
|
|
print "<tr>" .
|
|
|
|
"<td>tree</td>" .
|
2006-06-20 14:58:12 +00:00
|
|
|
"<td class=\"sha1\">" .
|
2006-08-22 14:52:50 +00:00
|
|
|
$cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash),
|
|
|
|
class => "list"}, $co{'tree'}) .
|
2005-08-07 18:26:27 +00:00
|
|
|
"</td>" .
|
2006-08-22 14:52:50 +00:00
|
|
|
"<td class=\"link\">" .
|
|
|
|
$cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$hash)},
|
|
|
|
"tree");
|
2006-08-17 15:29:46 +00:00
|
|
|
if ($have_snapshot) {
|
2006-08-22 14:52:50 +00:00
|
|
|
print " | " .
|
|
|
|
$cgi->a({-href => href(action=>"snapshot", hash=>$hash)}, "snapshot");
|
2006-08-17 15:29:46 +00:00
|
|
|
}
|
|
|
|
print "</td>" .
|
2005-08-07 18:25:42 +00:00
|
|
|
"</tr>\n";
|
2006-12-15 16:53:45 +00:00
|
|
|
|
2005-08-07 18:05:15 +00:00
|
|
|
foreach my $par (@$parents) {
|
2005-08-07 18:25:42 +00:00
|
|
|
print "<tr>" .
|
|
|
|
"<td>parent</td>" .
|
2006-08-22 14:52:50 +00:00
|
|
|
"<td class=\"sha1\">" .
|
|
|
|
$cgi->a({-href => href(action=>"commit", hash=>$par),
|
|
|
|
class => "list"}, $par) .
|
|
|
|
"</td>" .
|
2005-08-07 18:25:42 +00:00
|
|
|
"<td class=\"link\">" .
|
2006-08-15 22:24:30 +00:00
|
|
|
$cgi->a({-href => href(action=>"commit", hash=>$par)}, "commit") .
|
2006-08-22 14:52:50 +00:00
|
|
|
" | " .
|
2006-09-03 21:43:03 +00:00
|
|
|
$cgi->a({-href => href(action=>"commitdiff", hash=>$hash, hash_parent=>$par)}, "diff") .
|
2005-08-07 18:25:42 +00:00
|
|
|
"</td>" .
|
|
|
|
"</tr>\n";
|
2005-08-07 18:05:15 +00:00
|
|
|
}
|
2006-06-21 07:48:02 +00:00
|
|
|
print "</table>".
|
2005-08-07 18:21:04 +00:00
|
|
|
"</div>\n";
|
2006-08-17 09:21:23 +00:00
|
|
|
|
2005-08-07 18:12:11 +00:00
|
|
|
print "<div class=\"page_body\">\n";
|
2006-08-17 09:21:23 +00:00
|
|
|
git_print_log($co{'comment'});
|
2005-08-07 18:18:44 +00:00
|
|
|
print "</div>\n";
|
2006-08-14 00:18:33 +00:00
|
|
|
|
2006-12-15 16:53:45 +00:00
|
|
|
if (@$parents <= 1) {
|
|
|
|
# do not output difftree/whatchanged for merges
|
|
|
|
git_difftree_body(\@difftree, $hash, $parent);
|
|
|
|
}
|
2006-08-14 00:18:33 +00:00
|
|
|
|
2005-08-07 18:02:47 +00:00
|
|
|
git_footer_html();
|
2005-08-07 18:21:23 +00:00
|
|
|
}
|
|
|
|
|
2006-12-10 12:25:47 +00:00
|
|
|
sub git_object {
|
|
|
|
# object is defined by:
|
|
|
|
# - hash or hash_base alone
|
|
|
|
# - hash_base and file_name
|
|
|
|
my $type;
|
|
|
|
|
|
|
|
# - hash or hash_base alone
|
|
|
|
if ($hash || ($hash_base && !defined $file_name)) {
|
|
|
|
my $object_id = $hash || $hash_base;
|
|
|
|
|
|
|
|
my $git_command = git_cmd_str();
|
|
|
|
open my $fd, "-|", "$git_command cat-file -t $object_id 2>/dev/null"
|
|
|
|
or die_error('404 Not Found', "Object does not exist");
|
|
|
|
$type = <$fd>;
|
|
|
|
chomp $type;
|
|
|
|
close $fd
|
|
|
|
or die_error('404 Not Found', "Object does not exist");
|
|
|
|
|
|
|
|
# - hash_base and file_name
|
|
|
|
} elsif ($hash_base && defined $file_name) {
|
|
|
|
$file_name =~ s,/+$,,;
|
|
|
|
|
|
|
|
system(git_cmd(), "cat-file", '-e', $hash_base) == 0
|
|
|
|
or die_error('404 Not Found', "Base object does not exist");
|
|
|
|
|
|
|
|
# here errors should not hapen
|
|
|
|
open my $fd, "-|", git_cmd(), "ls-tree", $hash_base, "--", $file_name
|
|
|
|
or die_error(undef, "Open git-ls-tree failed");
|
|
|
|
my $line = <$fd>;
|
|
|
|
close $fd;
|
|
|
|
|
|
|
|
#'100644 blob 0fa3f3a66fb6a137f6ec2c19351ed4d807070ffa panic.c'
|
|
|
|
unless ($line && $line =~ m/^([0-9]+) (.+) ([0-9a-fA-F]{40})\t/) {
|
|
|
|
die_error('404 Not Found', "File or directory for given base does not exist");
|
|
|
|
}
|
|
|
|
$type = $2;
|
|
|
|
$hash = $3;
|
|
|
|
} else {
|
|
|
|
die_error('404 Not Found', "Not enough information to find object");
|
|
|
|
}
|
|
|
|
|
|
|
|
print $cgi->redirect(-uri => href(action=>$type, -full=>1,
|
|
|
|
hash=>$hash, hash_base=>$hash_base,
|
|
|
|
file_name=>$file_name),
|
|
|
|
-status => '302 Found');
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:21:23 +00:00
|
|
|
sub git_blobdiff {
|
2006-08-25 19:14:49 +00:00
|
|
|
my $format = shift || 'html';
|
|
|
|
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
my $fd;
|
|
|
|
my @difftree;
|
|
|
|
my %diffinfo;
|
2006-08-25 19:14:49 +00:00
|
|
|
my $expires;
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
|
|
|
|
# preparing $fd and %diffinfo for git_patchset_body
|
|
|
|
# new style URI
|
|
|
|
if (defined $hash_base && defined $hash_parent_base) {
|
|
|
|
if (defined $file_name) {
|
|
|
|
# read raw output
|
2006-10-30 21:29:06 +00:00
|
|
|
open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
|
|
|
|
$hash_parent_base, $hash_base,
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
"--", $file_name
|
|
|
|
or die_error(undef, "Open git-diff-tree failed");
|
|
|
|
@difftree = map { chomp; $_ } <$fd>;
|
|
|
|
close $fd
|
|
|
|
or die_error(undef, "Reading git-diff-tree failed");
|
|
|
|
@difftree
|
|
|
|
or die_error('404 Not Found', "Blob diff not found");
|
|
|
|
|
2006-08-27 21:45:26 +00:00
|
|
|
} elsif (defined $hash &&
|
|
|
|
$hash =~ /[0-9a-fA-F]{40}/) {
|
|
|
|
# try to find filename from $hash
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
|
|
|
|
# read filtered raw output
|
2006-10-30 21:29:06 +00:00
|
|
|
open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
|
|
|
|
$hash_parent_base, $hash_base, "--"
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
or die_error(undef, "Open git-diff-tree failed");
|
|
|
|
@difftree =
|
|
|
|
# ':100644 100644 03b21826... 3b93d5e7... M ls-files.c'
|
|
|
|
# $hash == to_id
|
|
|
|
grep { /^:[0-7]{6} [0-7]{6} [0-9a-fA-F]{40} $hash/ }
|
|
|
|
map { chomp; $_ } <$fd>;
|
|
|
|
close $fd
|
|
|
|
or die_error(undef, "Reading git-diff-tree failed");
|
|
|
|
@difftree
|
|
|
|
or die_error('404 Not Found', "Blob diff not found");
|
|
|
|
|
|
|
|
} else {
|
|
|
|
die_error('404 Not Found', "Missing one of the blob diff parameters");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (@difftree > 1) {
|
|
|
|
die_error('404 Not Found', "Ambiguous blob diff specification");
|
|
|
|
}
|
|
|
|
|
|
|
|
%diffinfo = parse_difftree_raw_line($difftree[0]);
|
|
|
|
$file_parent ||= $diffinfo{'from_file'} || $file_name || $diffinfo{'file'};
|
|
|
|
$file_name ||= $diffinfo{'to_file'} || $diffinfo{'file'};
|
|
|
|
|
|
|
|
$hash_parent ||= $diffinfo{'from_id'};
|
|
|
|
$hash ||= $diffinfo{'to_id'};
|
|
|
|
|
2006-08-25 19:14:49 +00:00
|
|
|
# non-textual hash id's can be cached
|
|
|
|
if ($hash_base =~ m/^[0-9a-fA-F]{40}$/ &&
|
|
|
|
$hash_parent_base =~ m/^[0-9a-fA-F]{40}$/) {
|
|
|
|
$expires = '+1d';
|
|
|
|
}
|
|
|
|
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
# open patch output
|
2006-08-28 15:49:58 +00:00
|
|
|
open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
|
2006-08-27 21:49:36 +00:00
|
|
|
'-p', $hash_parent_base, $hash_base,
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
"--", $file_name
|
|
|
|
or die_error(undef, "Open git-diff-tree failed");
|
|
|
|
}
|
|
|
|
|
|
|
|
# old/legacy style URI
|
|
|
|
if (!%diffinfo && # if new style URI failed
|
|
|
|
defined $hash && defined $hash_parent) {
|
|
|
|
# fake git-diff-tree raw output
|
|
|
|
$diffinfo{'from_mode'} = $diffinfo{'to_mode'} = "blob";
|
|
|
|
$diffinfo{'from_id'} = $hash_parent;
|
|
|
|
$diffinfo{'to_id'} = $hash;
|
|
|
|
if (defined $file_name) {
|
|
|
|
if (defined $file_parent) {
|
|
|
|
$diffinfo{'status'} = '2';
|
2006-09-24 21:57:40 +00:00
|
|
|
$diffinfo{'from_file'} = $file_parent;
|
|
|
|
$diffinfo{'to_file'} = $file_name;
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
} else { # assume not renamed
|
|
|
|
$diffinfo{'status'} = '1';
|
2006-09-24 21:57:40 +00:00
|
|
|
$diffinfo{'from_file'} = $file_name;
|
|
|
|
$diffinfo{'to_file'} = $file_name;
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
}
|
|
|
|
} else { # no filename given
|
|
|
|
$diffinfo{'status'} = '2';
|
|
|
|
$diffinfo{'from_file'} = $hash_parent;
|
|
|
|
$diffinfo{'to_file'} = $hash;
|
|
|
|
}
|
|
|
|
|
2006-08-25 19:14:49 +00:00
|
|
|
# non-textual hash id's can be cached
|
|
|
|
if ($hash =~ m/^[0-9a-fA-F]{40}$/ &&
|
|
|
|
$hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
|
|
|
|
$expires = '+1d';
|
|
|
|
}
|
|
|
|
|
|
|
|
# open patch output
|
2006-10-30 21:29:06 +00:00
|
|
|
open $fd, "-|", git_cmd(), "diff", '-p', @diff_opts,
|
|
|
|
$hash_parent, $hash, "--"
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
or die_error(undef, "Open git-diff failed");
|
|
|
|
} else {
|
|
|
|
die_error('404 Not Found', "Missing one of the blob diff parameters")
|
|
|
|
unless %diffinfo;
|
|
|
|
}
|
|
|
|
|
|
|
|
# header
|
2006-08-25 19:14:49 +00:00
|
|
|
if ($format eq 'html') {
|
|
|
|
my $formats_nav =
|
|
|
|
$cgi->a({-href => href(action=>"blobdiff_plain",
|
|
|
|
hash=>$hash, hash_parent=>$hash_parent,
|
|
|
|
hash_base=>$hash_base, hash_parent_base=>$hash_parent_base,
|
|
|
|
file_name=>$file_name, file_parent=>$file_parent)},
|
2006-09-22 01:19:50 +00:00
|
|
|
"raw");
|
2006-08-25 19:14:49 +00:00
|
|
|
git_header_html(undef, $expires);
|
|
|
|
if (defined $hash_base && (my %co = parse_commit($hash_base))) {
|
|
|
|
git_print_page_nav('','', $hash_base,$co{'tree'},$hash_base, $formats_nav);
|
|
|
|
git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
|
|
|
|
} else {
|
|
|
|
print "<div class=\"page_nav\"><br/>$formats_nav<br/></div>\n";
|
|
|
|
print "<div class=\"title\">$hash vs $hash_parent</div>\n";
|
|
|
|
}
|
|
|
|
if (defined $file_name) {
|
|
|
|
git_print_page_path($file_name, "blob", $hash_base);
|
|
|
|
} else {
|
|
|
|
print "<div class=\"page_path\"></div>\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
} elsif ($format eq 'plain') {
|
|
|
|
print $cgi->header(
|
|
|
|
-type => 'text/plain',
|
|
|
|
-charset => 'utf-8',
|
|
|
|
-expires => $expires,
|
2006-09-28 23:51:43 +00:00
|
|
|
-content_disposition => 'inline; filename="' . "$file_name" . '.patch"');
|
2006-08-25 19:14:49 +00:00
|
|
|
|
|
|
|
print "X-Git-Url: " . $cgi->self_url() . "\n\n";
|
|
|
|
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
} else {
|
2006-08-25 19:14:49 +00:00
|
|
|
die_error(undef, "Unknown blobdiff format");
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
# patch
|
2006-08-25 19:14:49 +00:00
|
|
|
if ($format eq 'html') {
|
|
|
|
print "<div class=\"page_body\">\n";
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
|
2006-08-25 19:14:49 +00:00
|
|
|
git_patchset_body($fd, [ \%diffinfo ], $hash_base, $hash_parent_base);
|
|
|
|
close $fd;
|
gitweb: Use git-diff-tree or git-diff patch output for blobdiff
This is second part of removing gitweb dependency on external
diff (used in git_diff_print).
Get rid of git_diff_print invocation in git_blobdiff, and use either
git-diff-tree (when both hash_base and hash_parent_base are provided)
patch format or git-diff patch format (when only hash and hash_parent
are provided) for output.
Supported URI schemes, and output formats:
* New URI scheme: both hash_base and hash_parent_base (trees-ish
containing blobs versions we want to compare) are provided.
Also either filename is provided, or hash (of blob) is provided
(we try to find filename then).
For this scheme we have copying and renames detection, mode changes,
file types etc., and information extended diff header is correct.
* Old URI scheme: hash_parent_base is not provided, we use hash and
hash_parent to directly compare blobs using git-diff. If no filename
is given, blobs hashes are used in place of filenames.
This scheme has always "blob" as file type, it cannot detect mode
changes, and we rely on CGI parameters to provide name of the file.
Added git_to_hash subroutine, which transforms symbolic name or list
of symbolic name to hash or list of hashes using git-rev-parse.
To have "blob" instead of "unknown" (or "file" regardless of the type)
in "gitweb diff header" for legacy scheme, file_type function now
returns its argument if it is not octal string.
Added support for fake "2" status code in git_patchset_body. Such code
is generated by git_blobdiff in legacy scheme case.
ATTENTION: The order of arguments (operands) to git-diff is reversed
(sic!) to have correct diff in the legacy (no hash_parent_base) case.
$hash_parent, $hash ordering is commented out, as it gives reversed
patch (at least for git version 1.4.1.1) as compared to output in new
scheme and output of older gitweb version.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-25 19:13:34 +00:00
|
|
|
|
2006-08-25 19:14:49 +00:00
|
|
|
print "</div>\n"; # class="page_body"
|
|
|
|
git_footer_html();
|
|
|
|
|
|
|
|
} else {
|
|
|
|
while (my $line = <$fd>) {
|
2006-11-08 10:48:56 +00:00
|
|
|
$line =~ s!a/($hash|$hash_parent)!'a/'.esc_path($diffinfo{'from_file'})!eg;
|
|
|
|
$line =~ s!b/($hash|$hash_parent)!'b/'.esc_path($diffinfo{'to_file'})!eg;
|
2006-08-25 19:14:49 +00:00
|
|
|
|
|
|
|
print $line;
|
|
|
|
|
|
|
|
last if $line =~ m!^\+\+\+!;
|
|
|
|
}
|
|
|
|
local $/ = undef;
|
|
|
|
print <$fd>;
|
|
|
|
close $fd;
|
|
|
|
}
|
2005-08-07 18:21:23 +00:00
|
|
|
}
|
|
|
|
|
2005-08-07 18:26:27 +00:00
|
|
|
sub git_blobdiff_plain {
|
2006-08-25 19:14:49 +00:00
|
|
|
git_blobdiff('plain');
|
2005-08-07 18:26:27 +00:00
|
|
|
}
|
|
|
|
|
2005-08-07 18:21:23 +00:00
|
|
|
sub git_commitdiff {
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
my $format = shift || 'html';
|
2006-11-18 22:35:41 +00:00
|
|
|
$hash ||= $hash_base || "HEAD";
|
2006-08-14 00:05:47 +00:00
|
|
|
my %co = parse_commit($hash);
|
2005-08-07 18:20:07 +00:00
|
|
|
if (!%co) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Unknown commit object");
|
2005-08-07 18:18:13 +00:00
|
|
|
}
|
2006-10-22 22:37:56 +00:00
|
|
|
|
|
|
|
# we need to prepare $formats_nav before any parameter munging
|
|
|
|
my $formats_nav;
|
|
|
|
if ($format eq 'html') {
|
|
|
|
$formats_nav =
|
|
|
|
$cgi->a({-href => href(action=>"commitdiff_plain",
|
|
|
|
hash=>$hash, hash_parent=>$hash_parent)},
|
|
|
|
"raw");
|
|
|
|
|
|
|
|
if (defined $hash_parent) {
|
|
|
|
# commitdiff with two commits given
|
|
|
|
my $hash_parent_short = $hash_parent;
|
|
|
|
if ($hash_parent =~ m/^[0-9a-fA-F]{40}$/) {
|
|
|
|
$hash_parent_short = substr($hash_parent, 0, 7);
|
|
|
|
}
|
|
|
|
$formats_nav .=
|
|
|
|
' (from: ' .
|
|
|
|
$cgi->a({-href => href(action=>"commitdiff",
|
|
|
|
hash=>$hash_parent)},
|
|
|
|
esc_html($hash_parent_short)) .
|
|
|
|
')';
|
|
|
|
} elsif (!$co{'parent'}) {
|
|
|
|
# --root commitdiff
|
|
|
|
$formats_nav .= ' (initial)';
|
|
|
|
} elsif (scalar @{$co{'parents'}} == 1) {
|
|
|
|
# single parent commit
|
|
|
|
$formats_nav .=
|
|
|
|
' (parent: ' .
|
|
|
|
$cgi->a({-href => href(action=>"commitdiff",
|
|
|
|
hash=>$co{'parent'})},
|
|
|
|
esc_html(substr($co{'parent'}, 0, 7))) .
|
|
|
|
')';
|
|
|
|
} else {
|
|
|
|
# merge commit
|
|
|
|
$formats_nav .=
|
|
|
|
' (merge: ' .
|
|
|
|
join(' ', map {
|
|
|
|
$cgi->a({-href => href(action=>"commitdiff",
|
|
|
|
hash=>$_)},
|
|
|
|
esc_html(substr($_, 0, 7)));
|
|
|
|
} @{$co{'parents'}} ) .
|
|
|
|
')';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:25:42 +00:00
|
|
|
if (!defined $hash_parent) {
|
2006-08-06 14:14:25 +00:00
|
|
|
$hash_parent = $co{'parent'} || '--root';
|
2005-08-07 18:25:42 +00:00
|
|
|
}
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
|
|
|
|
# read commitdiff
|
|
|
|
my $fd;
|
|
|
|
my @difftree;
|
|
|
|
if ($format eq 'html') {
|
2006-08-28 15:49:58 +00:00
|
|
|
open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
|
2006-10-30 21:29:06 +00:00
|
|
|
"--no-commit-id", "--patch-with-raw", "--full-index",
|
|
|
|
$hash_parent, $hash, "--"
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
or die_error(undef, "Open git-diff-tree failed");
|
|
|
|
|
2006-11-18 22:35:38 +00:00
|
|
|
while (my $line = <$fd>) {
|
|
|
|
chomp $line;
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
# empty line ends raw part of diff-tree output
|
|
|
|
last unless $line;
|
2006-10-26 08:50:20 +00:00
|
|
|
push @difftree, $line;
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} elsif ($format eq 'plain') {
|
2006-08-28 15:49:58 +00:00
|
|
|
open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
|
2006-10-30 21:29:06 +00:00
|
|
|
'-p', $hash_parent, $hash, "--"
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
or die_error(undef, "Open git-diff-tree failed");
|
2006-08-24 17:34:36 +00:00
|
|
|
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
} else {
|
|
|
|
die_error(undef, "Unknown commitdiff format");
|
|
|
|
}
|
2005-08-07 17:49:46 +00:00
|
|
|
|
2005-10-19 01:18:45 +00:00
|
|
|
# non-textual hash id's can be cached
|
|
|
|
my $expires;
|
|
|
|
if ($hash =~ m/^[0-9a-fA-F]{40}$/) {
|
|
|
|
$expires = "+1d";
|
|
|
|
}
|
2005-08-07 18:21:23 +00:00
|
|
|
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
# write commit message
|
|
|
|
if ($format eq 'html') {
|
|
|
|
my $refs = git_get_references();
|
|
|
|
my $ref = format_ref_marker($refs, $co{'id'});
|
2005-08-07 18:28:01 +00:00
|
|
|
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
git_header_html(undef, $expires);
|
|
|
|
git_print_page_nav('commitdiff','', $hash,$co{'tree'},$hash, $formats_nav);
|
|
|
|
git_print_header_div('commit', esc_html($co{'title'}) . $ref, $hash);
|
2006-08-28 12:48:12 +00:00
|
|
|
git_print_authorship(\%co);
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
print "<div class=\"page_body\">\n";
|
2006-10-24 11:55:33 +00:00
|
|
|
if (@{$co{'comment'}} > 1) {
|
|
|
|
print "<div class=\"log\">\n";
|
|
|
|
git_print_log($co{'comment'}, -final_empty_line=> 1, -remove_title => 1);
|
|
|
|
print "</div>\n"; # class="log"
|
|
|
|
}
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
|
|
|
|
} elsif ($format eq 'plain') {
|
|
|
|
my $refs = git_get_references("tags");
|
2006-08-24 17:45:30 +00:00
|
|
|
my $tagname = git_get_rev_name_tags($hash);
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
my $filename = basename($project) . "-$hash.patch";
|
|
|
|
|
|
|
|
print $cgi->header(
|
|
|
|
-type => 'text/plain',
|
|
|
|
-charset => 'utf-8',
|
|
|
|
-expires => $expires,
|
2006-09-28 23:51:43 +00:00
|
|
|
-content_disposition => 'inline; filename="' . "$filename" . '"');
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
my %ad = parse_date($co{'author_epoch'}, $co{'author_tz'});
|
|
|
|
print <<TEXT;
|
2006-08-22 21:42:53 +00:00
|
|
|
From: $co{'author'}
|
|
|
|
Date: $ad{'rfc2822'} ($ad{'tz_local'})
|
|
|
|
Subject: $co{'title'}
|
|
|
|
TEXT
|
2006-08-24 17:45:30 +00:00
|
|
|
print "X-Git-Tag: $tagname\n" if $tagname;
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
print "X-Git-Url: " . $cgi->self_url() . "\n\n";
|
2006-08-24 17:45:30 +00:00
|
|
|
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
foreach my $line (@{$co{'comment'}}) {
|
|
|
|
print "$line\n";
|
|
|
|
}
|
|
|
|
print "---\n\n";
|
2005-08-07 18:28:01 +00:00
|
|
|
}
|
|
|
|
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
# write patch
|
|
|
|
if ($format eq 'html') {
|
2006-08-28 12:48:14 +00:00
|
|
|
git_difftree_body(\@difftree, $hash, $hash_parent);
|
|
|
|
print "<br/>\n";
|
2005-08-07 18:28:01 +00:00
|
|
|
|
2006-08-24 17:34:36 +00:00
|
|
|
git_patchset_body($fd, \@difftree, $hash, $hash_parent);
|
|
|
|
close $fd;
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
print "</div>\n"; # class="page_body"
|
|
|
|
git_footer_html();
|
|
|
|
|
|
|
|
} elsif ($format eq 'plain') {
|
|
|
|
local $/ = undef;
|
|
|
|
print <$fd>;
|
|
|
|
close $fd
|
|
|
|
or print "Reading git-diff-tree failed\n";
|
2005-08-07 18:26:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
gitweb: Use git-diff-tree patch output for commitdiff
Get rid of git_diff_print invocation in git_commitdiff and therefore
external diff (/usr/bin/diff) invocation, and use only git-diff-tree
to generate patch.
git_commitdiff and git_commitdiff_plain are collapsed into one
subroutine git_commitdiff, with format (currently 'html' which is
default format corresponding to git_commitdiff, and 'plain'
corresponding to git_commitdiff_plain) specified in argument.
Separate patch (diff) pretty-printing into git_patchset_body.
It is used in git_commitdiff.
Separate patch (diff) line formatting from git_diff_print into
format_diff_line function. It is used in git_patchset_body.
While at it, add $hash parameter to git_difftree_body, according to
rule that inner functions should use parameter passing, and not global
variables.
CHANGES TO OUTPUT:
* "commitdiff" now products patches with renaming and copying
detection (git-diff-tree is invoked with -M and -C options).
Empty patches (mode changes and pure renames and copying)
are not written currently. Former version broke renaming and
copying, and didn't notice mode changes, like this version.
* "commitdiff" output is now divided into several div elements
of class "log", "patchset" and "patch".
* "commitdiff_plain" now only generates X-Git-Tag: line only if there
is tag pointing to the current commit. Former version which wrote
first tag following current commit was broken[*1*]; besides we are
interested rather in tags _preceding_ the commit, and _heads_
following the commit. X-Git-Url: now is current URL; former version
tried[*2*] to output URL to HTML version of commitdiff.
* "commitdiff_plain" is generated by git-diff-tree, and has therefore
has git specific extensions to diff format: "git diff" header and
optional extended header lines.
FOOTNOTES
[*1*] First it generated rev-list starting from HEAD even if hash_base
parameter was set, second it wasn't corrected according to changes
made in git_get_references (formerly read_info_ref) output, third even
for older version of read_info_ref output it didn't work for multiple
tags pointing to the current commit (rare).
[*2*] It wrote URL for commitdiff without hash_parent, which produces
diff to first parent and is not the same as current diff if it is diff
of merge commit to non-first parent.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-08-23 22:15:14 +00:00
|
|
|
sub git_commitdiff_plain {
|
|
|
|
git_commitdiff('plain');
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:21:23 +00:00
|
|
|
sub git_history {
|
2006-07-23 20:26:30 +00:00
|
|
|
if (!defined $hash_base) {
|
2006-08-14 00:05:47 +00:00
|
|
|
$hash_base = git_get_head_hash($project);
|
2005-08-07 18:21:23 +00:00
|
|
|
}
|
2006-09-10 22:36:04 +00:00
|
|
|
if (!defined $page) {
|
|
|
|
$page = 0;
|
|
|
|
}
|
2006-07-23 20:31:15 +00:00
|
|
|
my $ftype;
|
2006-08-14 00:05:47 +00:00
|
|
|
my %co = parse_commit($hash_base);
|
2005-08-07 18:21:23 +00:00
|
|
|
if (!%co) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Unknown commit object");
|
2005-08-07 18:17:00 +00:00
|
|
|
}
|
2006-09-10 22:36:04 +00:00
|
|
|
|
2006-08-14 00:05:47 +00:00
|
|
|
my $refs = git_get_references();
|
2006-09-10 22:36:04 +00:00
|
|
|
my $limit = sprintf("--max-count=%i", (100 * ($page+1)));
|
|
|
|
|
2006-07-23 20:30:08 +00:00
|
|
|
if (!defined $hash && defined $file_name) {
|
|
|
|
$hash = git_get_hash_by_path($hash_base, $file_name);
|
|
|
|
}
|
2006-07-23 20:28:55 +00:00
|
|
|
if (defined $hash) {
|
2006-07-23 20:31:15 +00:00
|
|
|
$ftype = git_get_type($hash);
|
2006-07-23 20:28:55 +00:00
|
|
|
}
|
2005-08-07 18:25:27 +00:00
|
|
|
|
2006-12-24 14:31:48 +00:00
|
|
|
my @commitlist = parse_commits($hash_base, 101, (100 * $page), "--full-history", $file_name);
|
2006-08-28 15:49:58 +00:00
|
|
|
|
2006-09-10 22:36:04 +00:00
|
|
|
my $paging_nav = '';
|
|
|
|
if ($page > 0) {
|
|
|
|
$paging_nav .=
|
|
|
|
$cgi->a({-href => href(action=>"history", hash=>$hash, hash_base=>$hash_base,
|
|
|
|
file_name=>$file_name)},
|
|
|
|
"first");
|
|
|
|
$paging_nav .= " ⋅ " .
|
|
|
|
$cgi->a({-href => href(action=>"history", hash=>$hash, hash_base=>$hash_base,
|
|
|
|
file_name=>$file_name, page=>$page-1),
|
|
|
|
-accesskey => "p", -title => "Alt-p"}, "prev");
|
|
|
|
} else {
|
|
|
|
$paging_nav .= "first";
|
|
|
|
$paging_nav .= " ⋅ prev";
|
|
|
|
}
|
2006-12-24 14:31:48 +00:00
|
|
|
if ($#commitlist >= 100) {
|
2006-09-10 22:36:04 +00:00
|
|
|
$paging_nav .= " ⋅ " .
|
|
|
|
$cgi->a({-href => href(action=>"history", hash=>$hash, hash_base=>$hash_base,
|
|
|
|
file_name=>$file_name, page=>$page+1),
|
|
|
|
-accesskey => "n", -title => "Alt-n"}, "next");
|
|
|
|
} else {
|
|
|
|
$paging_nav .= " ⋅ next";
|
|
|
|
}
|
|
|
|
my $next_link = '';
|
2006-12-24 14:31:48 +00:00
|
|
|
if ($#commitlist >= 100) {
|
2006-09-10 22:36:04 +00:00
|
|
|
$next_link =
|
|
|
|
$cgi->a({-href => href(action=>"history", hash=>$hash, hash_base=>$hash_base,
|
|
|
|
file_name=>$file_name, page=>$page+1),
|
2006-12-24 14:31:48 +00:00
|
|
|
-accesskey => "n", -title => "Alt-n"}, "next");
|
2006-09-10 22:36:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
git_header_html();
|
|
|
|
git_print_page_nav('history','', $hash_base,$co{'tree'},$hash_base, $paging_nav);
|
|
|
|
git_print_header_div('commit', esc_html($co{'title'}), $hash_base);
|
|
|
|
git_print_page_path($file_name, $ftype, $hash_base);
|
|
|
|
|
2006-12-24 14:31:48 +00:00
|
|
|
git_history_body(\@commitlist, 0, 99,
|
2006-09-10 22:36:04 +00:00
|
|
|
$refs, $hash_base, $ftype, $next_link);
|
2006-08-14 00:09:08 +00:00
|
|
|
|
2005-08-07 18:16:07 +00:00
|
|
|
git_footer_html();
|
2005-08-07 17:49:46 +00:00
|
|
|
}
|
2005-08-07 18:26:27 +00:00
|
|
|
|
|
|
|
sub git_search {
|
2006-12-23 03:35:16 +00:00
|
|
|
my ($have_search) = gitweb_check_feature('search');
|
|
|
|
if (!$have_search) {
|
|
|
|
die_error('403 Permission denied', "Permission denied");
|
|
|
|
}
|
2005-08-07 18:26:27 +00:00
|
|
|
if (!defined $searchtext) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Text field empty");
|
2005-08-07 18:26:27 +00:00
|
|
|
}
|
|
|
|
if (!defined $hash) {
|
2006-08-14 00:05:47 +00:00
|
|
|
$hash = git_get_head_hash($project);
|
2005-08-07 18:26:27 +00:00
|
|
|
}
|
2006-08-14 00:05:47 +00:00
|
|
|
my %co = parse_commit($hash);
|
2005-08-07 18:26:27 +00:00
|
|
|
if (!%co) {
|
2006-08-05 11:13:53 +00:00
|
|
|
die_error(undef, "Unknown commit object");
|
2005-08-07 18:26:27 +00:00
|
|
|
}
|
2006-12-23 14:57:12 +00:00
|
|
|
if (!defined $page) {
|
|
|
|
$page = 0;
|
|
|
|
}
|
2006-09-10 22:29:27 +00:00
|
|
|
|
2006-10-24 03:15:46 +00:00
|
|
|
$searchtype ||= 'commit';
|
|
|
|
if ($searchtype eq 'pickaxe') {
|
2006-09-10 22:29:27 +00:00
|
|
|
# pickaxe may take all resources of your box and run for several minutes
|
|
|
|
# with every query - so decide by yourself how public you make this feature
|
|
|
|
my ($have_pickaxe) = gitweb_check_feature('pickaxe');
|
|
|
|
if (!$have_pickaxe) {
|
|
|
|
die_error('403 Permission denied', "Permission denied");
|
|
|
|
}
|
2005-08-07 18:27:18 +00:00
|
|
|
}
|
2006-10-24 03:15:46 +00:00
|
|
|
|
2005-08-07 18:26:27 +00:00
|
|
|
git_header_html();
|
|
|
|
|
2006-10-24 03:15:46 +00:00
|
|
|
if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
|
2006-12-23 03:35:14 +00:00
|
|
|
my $greptype;
|
|
|
|
if ($searchtype eq 'commit') {
|
|
|
|
$greptype = "--grep=";
|
|
|
|
} elsif ($searchtype eq 'author') {
|
|
|
|
$greptype = "--author=";
|
|
|
|
} elsif ($searchtype eq 'committer') {
|
|
|
|
$greptype = "--committer=";
|
|
|
|
}
|
2006-12-24 14:31:46 +00:00
|
|
|
$greptype .= $searchtext;
|
|
|
|
my @commitlist = parse_commits($hash, 101, (100 * $page), $greptype);
|
2006-12-23 14:57:12 +00:00
|
|
|
|
|
|
|
my $paging_nav = '';
|
|
|
|
if ($page > 0) {
|
|
|
|
$paging_nav .=
|
|
|
|
$cgi->a({-href => href(action=>"search", hash=>$hash,
|
|
|
|
searchtext=>$searchtext, searchtype=>$searchtype)},
|
|
|
|
"first");
|
|
|
|
$paging_nav .= " ⋅ " .
|
|
|
|
$cgi->a({-href => href(action=>"search", hash=>$hash,
|
|
|
|
searchtext=>$searchtext, searchtype=>$searchtype,
|
|
|
|
page=>$page-1),
|
|
|
|
-accesskey => "p", -title => "Alt-p"}, "prev");
|
|
|
|
} else {
|
|
|
|
$paging_nav .= "first";
|
|
|
|
$paging_nav .= " ⋅ prev";
|
|
|
|
}
|
2006-12-24 14:31:46 +00:00
|
|
|
if ($#commitlist >= 100) {
|
2006-12-23 14:57:12 +00:00
|
|
|
$paging_nav .= " ⋅ " .
|
|
|
|
$cgi->a({-href => href(action=>"search", hash=>$hash,
|
|
|
|
searchtext=>$searchtext, searchtype=>$searchtype,
|
|
|
|
page=>$page+1),
|
|
|
|
-accesskey => "n", -title => "Alt-n"}, "next");
|
|
|
|
} else {
|
|
|
|
$paging_nav .= " ⋅ next";
|
|
|
|
}
|
|
|
|
my $next_link = '';
|
2006-12-24 14:31:46 +00:00
|
|
|
if ($#commitlist >= 100) {
|
2006-12-23 14:57:12 +00:00
|
|
|
$next_link =
|
|
|
|
$cgi->a({-href => href(action=>"search", hash=>$hash,
|
|
|
|
searchtext=>$searchtext, searchtype=>$searchtype,
|
|
|
|
page=>$page+1),
|
|
|
|
-accesskey => "n", -title => "Alt-n"}, "next");
|
|
|
|
}
|
|
|
|
|
|
|
|
git_print_page_nav('','', $hash,$co{'tree'},$hash, $paging_nav);
|
|
|
|
git_print_header_div('commit', esc_html($co{'title'}), $hash);
|
2006-12-24 14:31:46 +00:00
|
|
|
git_search_grep_body(\@commitlist, 0, 99, $next_link);
|
2005-08-07 18:27:18 +00:00
|
|
|
}
|
|
|
|
|
2006-10-24 03:15:46 +00:00
|
|
|
if ($searchtype eq 'pickaxe') {
|
2006-12-23 14:57:12 +00:00
|
|
|
git_print_page_nav('','', $hash,$co{'tree'},$hash);
|
|
|
|
git_print_header_div('commit', esc_html($co{'title'}), $hash);
|
|
|
|
|
|
|
|
print "<table cellspacing=\"0\">\n";
|
|
|
|
my $alternate = 1;
|
2005-08-07 18:27:18 +00:00
|
|
|
$/ = "\n";
|
2006-08-28 15:49:58 +00:00
|
|
|
my $git_command = git_cmd_str();
|
|
|
|
open my $fd, "-|", "$git_command rev-list $hash | " .
|
|
|
|
"$git_command diff-tree -r --stdin -S\'$searchtext\'";
|
2005-08-07 18:27:18 +00:00
|
|
|
undef %co;
|
|
|
|
my @files;
|
|
|
|
while (my $line = <$fd>) {
|
|
|
|
if (%co && $line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)\t(.*)$/) {
|
|
|
|
my %set;
|
|
|
|
$set{'file'} = $6;
|
|
|
|
$set{'from_id'} = $3;
|
|
|
|
$set{'to_id'} = $4;
|
|
|
|
$set{'id'} = $set{'to_id'};
|
|
|
|
if ($set{'id'} =~ m/0{40}/) {
|
|
|
|
$set{'id'} = $set{'from_id'};
|
2005-08-07 18:26:27 +00:00
|
|
|
}
|
2005-08-07 18:27:18 +00:00
|
|
|
if ($set{'id'} =~ m/0{40}/) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
push @files, \%set;
|
2005-08-12 20:12:58 +00:00
|
|
|
} elsif ($line =~ m/^([0-9a-fA-F]{40})$/){
|
2005-08-07 18:27:18 +00:00
|
|
|
if (%co) {
|
|
|
|
if ($alternate) {
|
|
|
|
print "<tr class=\"dark\">\n";
|
|
|
|
} else {
|
|
|
|
print "<tr class=\"light\">\n";
|
|
|
|
}
|
|
|
|
$alternate ^= 1;
|
2005-08-07 18:27:27 +00:00
|
|
|
print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
|
replace invalid utf8 sequences by UTF-8 REPLACEMENT CHARACTER (efbfbd)
I still strongly disagree with the git maintainers not to hint people,
to use the only sane default encoding for a distributed project,
which is utf8. I'm tired of hearing filesystem development arguments.
Git is a software offered to merge forth and back across the world
and not to provide a content neutral filesystem.
Btw: I have nothing against the ability to run git in a closed environment,
with a different encoding, that's fine, sure. But that is obviously not
the case for the projects on kernel.org. It's about sane defaults,
nothing else.
You have to make decisions guy, as always in life. The problems to
allow random encoded garbage in commit messages _without_ storing
the encoding, just makes zero sense. Eighter you introduce a per-commit
encoding field, if you insist on this craziness, or you define a default
encoding. Everything else is just lazy and does not solve any problem,
besides that you can claim now, that you are not responsible for the mess
in the repository.
Gitweb shows several commits at once, you allow various encodings committed
to the same repository, without any hint what that garbage from the
individual commits is encoded with. No idea why you don't get
the problem - it's unsolvable. If you merge different peoples work, you
have to speak a common language!
Kay Sievers <kay.sievers@vrfy.org>
2005-11-19 16:41:29 +00:00
|
|
|
"<td><i>" . esc_html(chop_str($co{'author_name'}, 15, 5)) . "</i></td>\n" .
|
2005-08-07 18:27:18 +00:00
|
|
|
"<td>" .
|
2006-08-22 14:52:50 +00:00
|
|
|
$cgi->a({-href => href(action=>"commit", hash=>$co{'id'}),
|
|
|
|
-class => "list subject"},
|
2006-08-22 10:38:59 +00:00
|
|
|
esc_html(chop_str($co{'title'}, 50)) . "<br/>");
|
2005-08-07 18:27:18 +00:00
|
|
|
while (my $setref = shift @files) {
|
|
|
|
my %set = %$setref;
|
2006-08-22 14:52:50 +00:00
|
|
|
print $cgi->a({-href => href(action=>"blob", hash_base=>$co{'id'},
|
|
|
|
hash=>$set{'id'}, file_name=>$set{'file'}),
|
|
|
|
-class => "list"},
|
2006-11-08 10:48:56 +00:00
|
|
|
"<span class=\"match\">" . esc_path($set{'file'}) . "</span>") .
|
2005-08-07 18:27:18 +00:00
|
|
|
"<br/>\n";
|
|
|
|
}
|
|
|
|
print "</td>\n" .
|
|
|
|
"<td class=\"link\">" .
|
2006-08-16 22:28:36 +00:00
|
|
|
$cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
|
2006-08-22 14:52:50 +00:00
|
|
|
" | " .
|
|
|
|
$cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
|
2005-08-07 18:27:18 +00:00
|
|
|
print "</td>\n" .
|
|
|
|
"</tr>\n";
|
|
|
|
}
|
2006-08-14 00:05:47 +00:00
|
|
|
%co = parse_commit($1);
|
2005-08-07 18:26:27 +00:00
|
|
|
}
|
|
|
|
}
|
2005-08-07 18:27:18 +00:00
|
|
|
close $fd;
|
2006-12-23 14:57:12 +00:00
|
|
|
|
|
|
|
print "</table>\n";
|
2005-08-07 18:26:27 +00:00
|
|
|
}
|
|
|
|
git_footer_html();
|
|
|
|
}
|
|
|
|
|
2006-10-24 03:15:46 +00:00
|
|
|
sub git_search_help {
|
|
|
|
git_header_html();
|
|
|
|
git_print_page_nav('','', $hash,$hash,$hash);
|
|
|
|
print <<EOT;
|
|
|
|
<dl>
|
|
|
|
<dt><b>commit</b></dt>
|
|
|
|
<dd>The commit messages and authorship information will be scanned for the given string.</dd>
|
|
|
|
<dt><b>author</b></dt>
|
|
|
|
<dd>Name and e-mail of the change author and date of birth of the patch will be scanned for the given string.</dd>
|
|
|
|
<dt><b>committer</b></dt>
|
|
|
|
<dd>Name and e-mail of the committer and date of commit will be scanned for the given string.</dd>
|
|
|
|
EOT
|
|
|
|
my ($have_pickaxe) = gitweb_check_feature('pickaxe');
|
|
|
|
if ($have_pickaxe) {
|
|
|
|
print <<EOT;
|
|
|
|
<dt><b>pickaxe</b></dt>
|
|
|
|
<dd>All commits that caused the string to appear or disappear from any file (changes that
|
|
|
|
added, removed or "modified" the string) will be listed. This search can take a while and
|
|
|
|
takes a lot of strain on the server, so please use it wisely.</dd>
|
|
|
|
EOT
|
|
|
|
}
|
|
|
|
print "</dl>\n";
|
|
|
|
git_footer_html();
|
|
|
|
}
|
|
|
|
|
2005-08-07 18:26:27 +00:00
|
|
|
sub git_shortlog {
|
2006-08-14 00:05:47 +00:00
|
|
|
my $head = git_get_head_hash($project);
|
2005-08-07 18:26:27 +00:00
|
|
|
if (!defined $hash) {
|
|
|
|
$hash = $head;
|
|
|
|
}
|
2005-08-07 18:26:49 +00:00
|
|
|
if (!defined $page) {
|
|
|
|
$page = 0;
|
|
|
|
}
|
2006-08-14 00:05:47 +00:00
|
|
|
my $refs = git_get_references();
|
2005-08-07 18:26:49 +00:00
|
|
|
|
2007-01-03 20:25:55 +00:00
|
|
|
my @commitlist = parse_commits($hash, 101, (100 * $page));
|
2005-08-07 18:26:49 +00:00
|
|
|
|
2006-12-24 14:31:44 +00:00
|
|
|
my $paging_nav = format_paging_nav('shortlog', $hash, $head, $page, (100 * ($page+1)));
|
2006-07-31 09:22:13 +00:00
|
|
|
my $next_link = '';
|
2006-12-24 14:31:44 +00:00
|
|
|
if ($#commitlist >= 100) {
|
2006-07-31 09:22:13 +00:00
|
|
|
$next_link =
|
2006-08-16 22:28:36 +00:00
|
|
|
$cgi->a({-href => href(action=>"shortlog", hash=>$hash, page=>$page+1),
|
2006-12-24 14:31:44 +00:00
|
|
|
-accesskey => "n", -title => "Alt-n"}, "next");
|
2006-07-31 09:22:13 +00:00
|
|
|
}
|
|
|
|
|
2006-07-30 13:01:07 +00:00
|
|
|
git_header_html();
|
2006-08-14 00:05:47 +00:00
|
|
|
git_print_page_nav('shortlog','', $hash,$hash,$hash, $paging_nav);
|
|
|
|
git_print_header_div('summary', $project);
|
2006-07-30 13:01:07 +00:00
|
|
|
|
2006-12-24 14:31:44 +00:00
|
|
|
git_shortlog_body(\@commitlist, 0, 99, $refs, $next_link);
|
2006-07-31 09:22:13 +00:00
|
|
|
|
2005-08-07 18:26:27 +00:00
|
|
|
git_footer_html();
|
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
## ......................................................................
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
## feeds (RSS, Atom; OPML)
|
2006-07-31 19:22:15 +00:00
|
|
|
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
sub git_feed {
|
|
|
|
my $format = shift || 'atom';
|
|
|
|
my ($have_blame) = gitweb_check_feature('blame');
|
|
|
|
|
|
|
|
# Atom: http://www.atomenabled.org/developers/syndication/
|
|
|
|
# RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
|
|
|
|
if ($format ne 'rss' && $format ne 'atom') {
|
|
|
|
die_error(undef, "Unknown web feed format");
|
|
|
|
}
|
|
|
|
|
|
|
|
# log/feed of current (HEAD) branch, log of given branch, history of file/directory
|
|
|
|
my $head = $hash || 'HEAD';
|
2006-12-24 14:31:47 +00:00
|
|
|
my @commitlist = parse_commits($head, 150);
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
|
|
|
|
my %latest_commit;
|
|
|
|
my %latest_date;
|
|
|
|
my $content_type = "application/$format+xml";
|
|
|
|
if (defined $cgi->http('HTTP_ACCEPT') &&
|
|
|
|
$cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
|
|
|
|
# browser (feed reader) prefers text/xml
|
|
|
|
$content_type = 'text/xml';
|
|
|
|
}
|
2006-12-24 14:31:47 +00:00
|
|
|
if (defined($commitlist[0])) {
|
|
|
|
%latest_commit = %{$commitlist[0]};
|
2006-11-25 14:54:34 +00:00
|
|
|
%latest_date = parse_date($latest_commit{'author_epoch'});
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
print $cgi->header(
|
|
|
|
-type => $content_type,
|
|
|
|
-charset => 'utf-8',
|
|
|
|
-last_modified => $latest_date{'rfc2822'});
|
|
|
|
} else {
|
|
|
|
print $cgi->header(
|
|
|
|
-type => $content_type,
|
|
|
|
-charset => 'utf-8');
|
|
|
|
}
|
|
|
|
|
|
|
|
# Optimization: skip generating the body if client asks only
|
|
|
|
# for Last-Modified date.
|
|
|
|
return if ($cgi->request_method() eq 'HEAD');
|
|
|
|
|
|
|
|
# header variables
|
|
|
|
my $title = "$site_name - $project/$action";
|
|
|
|
my $feed_type = 'log';
|
|
|
|
if (defined $hash) {
|
|
|
|
$title .= " - '$hash'";
|
|
|
|
$feed_type = 'branch log';
|
|
|
|
if (defined $file_name) {
|
|
|
|
$title .= " :: $file_name";
|
|
|
|
$feed_type = 'history';
|
|
|
|
}
|
|
|
|
} elsif (defined $file_name) {
|
|
|
|
$title .= " - $file_name";
|
|
|
|
$feed_type = 'history';
|
|
|
|
}
|
|
|
|
$title .= " $feed_type";
|
|
|
|
my $descr = git_get_project_description($project);
|
|
|
|
if (defined $descr) {
|
|
|
|
$descr = esc_html($descr);
|
|
|
|
} else {
|
|
|
|
$descr = "$project " .
|
|
|
|
($format eq 'rss' ? 'RSS' : 'Atom') .
|
|
|
|
" feed";
|
|
|
|
}
|
|
|
|
my $owner = git_get_project_owner($project);
|
|
|
|
$owner = esc_html($owner);
|
|
|
|
|
|
|
|
#header
|
|
|
|
my $alt_url;
|
|
|
|
if (defined $file_name) {
|
|
|
|
$alt_url = href(-full=>1, action=>"history", hash=>$hash, file_name=>$file_name);
|
|
|
|
} elsif (defined $hash) {
|
|
|
|
$alt_url = href(-full=>1, action=>"log", hash=>$hash);
|
|
|
|
} else {
|
|
|
|
$alt_url = href(-full=>1, action=>"summary");
|
|
|
|
}
|
|
|
|
print qq!<?xml version="1.0" encoding="utf-8"?>\n!;
|
|
|
|
if ($format eq 'rss') {
|
|
|
|
print <<XML;
|
2006-08-22 21:42:53 +00:00
|
|
|
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
|
|
|
|
<channel>
|
|
|
|
XML
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
print "<title>$title</title>\n" .
|
|
|
|
"<link>$alt_url</link>\n" .
|
|
|
|
"<description>$descr</description>\n" .
|
|
|
|
"<language>en</language>\n";
|
|
|
|
} elsif ($format eq 'atom') {
|
|
|
|
print <<XML;
|
|
|
|
<feed xmlns="http://www.w3.org/2005/Atom">
|
|
|
|
XML
|
|
|
|
print "<title>$title</title>\n" .
|
|
|
|
"<subtitle>$descr</subtitle>\n" .
|
|
|
|
'<link rel="alternate" type="text/html" href="' .
|
|
|
|
$alt_url . '" />' . "\n" .
|
|
|
|
'<link rel="self" type="' . $content_type . '" href="' .
|
|
|
|
$cgi->self_url() . '" />' . "\n" .
|
|
|
|
"<id>" . href(-full=>1) . "</id>\n" .
|
|
|
|
# use project owner for feed author
|
|
|
|
"<author><name>$owner</name></author>\n";
|
|
|
|
if (defined $favicon) {
|
|
|
|
print "<icon>" . esc_url($favicon) . "</icon>\n";
|
|
|
|
}
|
|
|
|
if (defined $logo_url) {
|
|
|
|
# not twice as wide as tall: 72 x 27 pixels
|
2006-12-04 13:09:43 +00:00
|
|
|
print "<logo>" . esc_url($logo) . "</logo>\n";
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
}
|
|
|
|
if (! %latest_date) {
|
|
|
|
# dummy date to keep the feed valid until commits trickle in:
|
|
|
|
print "<updated>1970-01-01T00:00:00Z</updated>\n";
|
|
|
|
} else {
|
|
|
|
print "<updated>$latest_date{'iso-8601'}</updated>\n";
|
|
|
|
}
|
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
# contents
|
2006-12-24 14:31:47 +00:00
|
|
|
for (my $i = 0; $i <= $#commitlist; $i++) {
|
|
|
|
my %co = %{$commitlist[$i]};
|
|
|
|
my $commit = $co{'id'};
|
2006-07-31 19:22:15 +00:00
|
|
|
# we read 150, we always show 30 and the ones more recent than 48 hours
|
2006-11-25 14:54:34 +00:00
|
|
|
if (($i >= 20) && ((time - $co{'author_epoch'}) > 48*60*60)) {
|
2006-07-31 19:22:15 +00:00
|
|
|
last;
|
|
|
|
}
|
2006-11-25 14:54:34 +00:00
|
|
|
my %cd = parse_date($co{'author_epoch'});
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
|
|
|
|
# get list of changed files
|
2006-12-24 14:31:47 +00:00
|
|
|
open my $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
$co{'parent'}, $co{'id'}, "--", (defined $file_name ? $file_name : ())
|
2006-08-27 21:49:36 +00:00
|
|
|
or next;
|
2006-07-31 19:22:15 +00:00
|
|
|
my @difftree = map { chomp; $_ } <$fd>;
|
2006-08-27 21:49:36 +00:00
|
|
|
close $fd
|
|
|
|
or next;
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
|
|
|
|
# print element (entry, item)
|
|
|
|
my $co_url = href(-full=>1, action=>"commit", hash=>$commit);
|
|
|
|
if ($format eq 'rss') {
|
|
|
|
print "<item>\n" .
|
|
|
|
"<title>" . esc_html($co{'title'}) . "</title>\n" .
|
|
|
|
"<author>" . esc_html($co{'author'}) . "</author>\n" .
|
|
|
|
"<pubDate>$cd{'rfc2822'}</pubDate>\n" .
|
|
|
|
"<guid isPermaLink=\"true\">$co_url</guid>\n" .
|
|
|
|
"<link>$co_url</link>\n" .
|
|
|
|
"<description>" . esc_html($co{'title'}) . "</description>\n" .
|
|
|
|
"<content:encoded>" .
|
|
|
|
"<![CDATA[\n";
|
|
|
|
} elsif ($format eq 'atom') {
|
|
|
|
print "<entry>\n" .
|
|
|
|
"<title type=\"html\">" . esc_html($co{'title'}) . "</title>\n" .
|
|
|
|
"<updated>$cd{'iso-8601'}</updated>\n" .
|
2006-11-25 14:54:33 +00:00
|
|
|
"<author>\n" .
|
|
|
|
" <name>" . esc_html($co{'author_name'}) . "</name>\n";
|
|
|
|
if ($co{'author_email'}) {
|
|
|
|
print " <email>" . esc_html($co{'author_email'}) . "</email>\n";
|
|
|
|
}
|
|
|
|
print "</author>\n" .
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
# use committer for contributor
|
2006-11-25 14:54:33 +00:00
|
|
|
"<contributor>\n" .
|
|
|
|
" <name>" . esc_html($co{'committer_name'}) . "</name>\n";
|
|
|
|
if ($co{'committer_email'}) {
|
|
|
|
print " <email>" . esc_html($co{'committer_email'}) . "</email>\n";
|
|
|
|
}
|
|
|
|
print "</contributor>\n" .
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
"<published>$cd{'iso-8601'}</published>\n" .
|
|
|
|
"<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
|
|
|
|
"<id>$co_url</id>\n" .
|
|
|
|
"<content type=\"xhtml\" xml:base=\"" . esc_url($my_url) . "\">\n" .
|
|
|
|
"<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
|
|
|
|
}
|
2006-07-31 19:22:15 +00:00
|
|
|
my $comment = $co{'comment'};
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
print "<pre>\n";
|
2006-07-31 19:22:15 +00:00
|
|
|
foreach my $line (@$comment) {
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
$line = esc_html($line);
|
|
|
|
print "$line\n";
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
print "</pre><ul>\n";
|
|
|
|
foreach my $difftree_line (@difftree) {
|
|
|
|
my %difftree = parse_difftree_raw_line($difftree_line);
|
|
|
|
next if !$difftree{'from_id'};
|
|
|
|
|
|
|
|
my $file = $difftree{'file'} || $difftree{'to_file'};
|
|
|
|
|
|
|
|
print "<li>" .
|
|
|
|
"[" .
|
|
|
|
$cgi->a({-href => href(-full=>1, action=>"blobdiff",
|
|
|
|
hash=>$difftree{'to_id'}, hash_parent=>$difftree{'from_id'},
|
|
|
|
hash_base=>$co{'id'}, hash_parent_base=>$co{'parent'},
|
|
|
|
file_name=>$file, file_parent=>$difftree{'from_file'}),
|
|
|
|
-title => "diff"}, 'D');
|
|
|
|
if ($have_blame) {
|
|
|
|
print $cgi->a({-href => href(-full=>1, action=>"blame",
|
|
|
|
file_name=>$file, hash_base=>$commit),
|
|
|
|
-title => "blame"}, 'B');
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
# if this is not a feed of a file history
|
|
|
|
if (!defined $file_name || $file_name ne $file) {
|
|
|
|
print $cgi->a({-href => href(-full=>1, action=>"history",
|
|
|
|
file_name=>$file, hash=>$commit),
|
|
|
|
-title => "history"}, 'H');
|
|
|
|
}
|
|
|
|
$file = esc_path($file);
|
|
|
|
print "] ".
|
|
|
|
"$file</li>\n";
|
|
|
|
}
|
|
|
|
if ($format eq 'rss') {
|
|
|
|
print "</ul>]]>\n" .
|
|
|
|
"</content:encoded>\n" .
|
|
|
|
"</item>\n";
|
|
|
|
} elsif ($format eq 'atom') {
|
|
|
|
print "</ul>\n</div>\n" .
|
|
|
|
"</content>\n" .
|
|
|
|
"</entry>\n";
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
|
|
|
}
|
gitweb: Refactor feed generation, make output prettier, add Atom feed
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-11-19 14:05:22 +00:00
|
|
|
|
|
|
|
# end of feed
|
|
|
|
if ($format eq 'rss') {
|
|
|
|
print "</channel>\n</rss>\n";
|
|
|
|
} elsif ($format eq 'atom') {
|
|
|
|
print "</feed>\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sub git_rss {
|
|
|
|
git_feed('rss');
|
|
|
|
}
|
|
|
|
|
|
|
|
sub git_atom {
|
|
|
|
git_feed('atom');
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sub git_opml {
|
2006-08-14 00:05:47 +00:00
|
|
|
my @list = git_get_projects_list();
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
print $cgi->header(-type => 'text/xml', -charset => 'utf-8');
|
2006-08-22 21:42:53 +00:00
|
|
|
print <<XML;
|
|
|
|
<?xml version="1.0" encoding="utf-8"?>
|
|
|
|
<opml version="1.0">
|
|
|
|
<head>
|
2006-10-24 03:18:39 +00:00
|
|
|
<title>$site_name OPML Export</title>
|
2006-08-22 21:42:53 +00:00
|
|
|
</head>
|
|
|
|
<body>
|
|
|
|
<outline text="git RSS feeds">
|
|
|
|
XML
|
2006-07-31 19:22:15 +00:00
|
|
|
|
|
|
|
foreach my $pr (@list) {
|
|
|
|
my %proj = %$pr;
|
2006-08-14 00:05:47 +00:00
|
|
|
my $head = git_get_head_hash($proj{'path'});
|
2006-07-31 19:22:15 +00:00
|
|
|
if (!defined $head) {
|
|
|
|
next;
|
|
|
|
}
|
2006-08-28 15:49:58 +00:00
|
|
|
$git_dir = "$projectroot/$proj{'path'}";
|
2006-08-14 00:05:47 +00:00
|
|
|
my %co = parse_commit($head);
|
2006-07-31 19:22:15 +00:00
|
|
|
if (!%co) {
|
|
|
|
next;
|
|
|
|
}
|
|
|
|
|
|
|
|
my $path = esc_html(chop_str($proj{'path'}, 25, 5));
|
|
|
|
my $rss = "$my_url?p=$proj{'path'};a=rss";
|
|
|
|
my $html = "$my_url?p=$proj{'path'};a=summary";
|
|
|
|
print "<outline type=\"rss\" text=\"$path\" title=\"$path\" xmlUrl=\"$rss\" htmlUrl=\"$html\"/>\n";
|
|
|
|
}
|
2006-08-22 21:42:53 +00:00
|
|
|
print <<XML;
|
|
|
|
</outline>
|
|
|
|
</body>
|
|
|
|
</opml>
|
|
|
|
XML
|
2006-07-31 19:22:15 +00:00
|
|
|
}
|