X-Git-Url: http://git.vanrenterghem.biz/git.ikiwiki.info.git/blobdiff_plain/4ef96e2d9994c407f0f2f46301eb91fab6b48a37..59632384d963ec07b406d413df68079af794b56e:/IkiWiki/Plugin/git.pm diff --git a/IkiWiki/Plugin/git.pm b/IkiWiki/Plugin/git.pm index b20793d86..23b99151e 100644 --- a/IkiWiki/Plugin/git.pm +++ b/IkiWiki/Plugin/git.pm @@ -5,14 +5,17 @@ use warnings; use strict; use IkiWiki; use Encode; +use File::Path qw{remove_tree}; +use URI::Escape q{uri_escape_utf8}; use open qw{:utf8 :std}; my $sha1_pattern = qr/[0-9a-fA-F]{40}/; # pattern to validate Git sha1sums my $dummy_commit_msg = 'dummy commit'; # message to skip in recent changes -sub import { #{{{ +sub import { hook(type => "checkconfig", id => "git", call => \&checkconfig); hook(type => "getsetup", id => "git", call => \&getsetup); + hook(type => "genwrapper", id => "git", call => \&genwrapper); hook(type => "rcs", id => "rcs_update", call => \&rcs_update); hook(type => "rcs", id => "rcs_prepedit", call => \&rcs_prepedit); hook(type => "rcs", id => "rcs_commit", call => \&rcs_commit); @@ -23,35 +26,73 @@ sub import { #{{{ hook(type => "rcs", id => "rcs_recentchanges", call => \&rcs_recentchanges); hook(type => "rcs", id => "rcs_diff", call => \&rcs_diff); hook(type => "rcs", id => "rcs_getctime", call => \&rcs_getctime); -} #}}} + hook(type => "rcs", id => "rcs_getmtime", call => \&rcs_getmtime); + hook(type => "rcs", id => "rcs_receive", call => \&rcs_receive); + hook(type => "rcs", id => "rcs_preprevert", call => \&rcs_preprevert); + hook(type => "rcs", id => "rcs_revert", call => \&rcs_revert); + hook(type => "rcs", id => "rcs_find_changes", call => \&rcs_find_changes); + hook(type => "rcs", id => "rcs_get_current_rev", call => \&rcs_get_current_rev); +} -sub checkconfig () { #{{{ - if (! defined $config{diffurl}) { - $config{diffurl}=""; - } +sub checkconfig () { if (! defined $config{gitorigin_branch}) { $config{gitorigin_branch}="origin"; } if (! defined $config{gitmaster_branch}) { $config{gitmaster_branch}="master"; } - if (defined $config{git_wrapper} && length $config{git_wrapper}) { + if (defined $config{git_wrapper} && + length $config{git_wrapper}) { push @{$config{wrappers}}, { wrapper => $config{git_wrapper}, wrappermode => (defined $config{git_wrappermode} ? $config{git_wrappermode} : "06755"), + wrapper_background_command => $config{git_wrapper_background_command}, + }; + } + + if (defined $config{git_test_receive_wrapper} && + length $config{git_test_receive_wrapper} && + defined $config{untrusted_committers} && + @{$config{untrusted_committers}}) { + push @{$config{wrappers}}, { + test_receive => 1, + wrapper => $config{git_test_receive_wrapper}, + wrappermode => (defined $config{git_wrappermode} ? $config{git_wrappermode} : "06755"), }; } -} #}}} -sub getsetup () { #{{{ + # Avoid notes, parser does not handle and they only slow things down. + $ENV{GIT_NOTES_REF}=""; + + # Run receive test only if being called by the wrapper, and not + # when generating same. + if ($config{test_receive} && ! exists $config{wrapper}) { + require IkiWiki::Receive; + IkiWiki::Receive::test(); + } +} + +sub getsetup () { return + plugin => { + safe => 0, # rcs plugin + rebuild => undef, + section => "rcs", + }, git_wrapper => { type => "string", example => "/git/wiki.git/hooks/post-update", - description => "git post-update executable to generate", + description => "git hook to generate", safe => 0, # file rebuild => 0, }, + git_wrapper_background_command => { + type => "string", + example => "git push github", + description => "shell command for git_wrapper to run, in the background", + safe => 0, # command + rebuild => 0, + }, git_wrappermode => { type => "string", example => '06755', @@ -59,17 +100,31 @@ sub getsetup () { #{{{ safe => 0, rebuild => 0, }, + git_test_receive_wrapper => { + type => "string", + example => "/git/wiki.git/hooks/pre-receive", + description => "git pre-receive hook to generate", + safe => 0, # file + rebuild => 0, + }, + untrusted_committers => { + type => "string", + example => [], + description => "unix users whose commits should be checked by the pre-receive hook", + safe => 0, + rebuild => 0, + }, historyurl => { type => "string", - example => "http://git.example.com/gitweb.cgi?p=wiki.git;a=history;f=[[file]]", + example => "http://git.example.com/gitweb.cgi?p=wiki.git;a=history;f=[[file]];hb=HEAD", description => "gitweb url to show file history ([[file]] substituted)", safe => 1, rebuild => 1, }, diffurl => { type => "string", - example => "http://git.example.com/gitweb.cgi?p=wiki.git;a=blobdiff;h=[[sha1_to]];hp=[[sha1_from]];hb=[[sha1_parent]];f=[[file]]", - description => "gitweb url to show a diff ([[sha1_to]], [[sha1_from]], [[sha1_parent]], and [[file]] substituted)", + example => "http://git.example.com/gitweb.cgi?p=wiki.git;a=blobdiff;f=[[file]];h=[[sha1_to]];hp=[[sha1_from]];hb=[[sha1_commit]];hpb=[[sha1_parent]]", + description => "gitweb url to show a diff ([[file]], [[sha1_to]], [[sha1_from]], [[sha1_commit]], and [[sha1_parent]] substituted)", safe => 1, rebuild => 1, }, @@ -87,46 +142,138 @@ sub getsetup () { #{{{ safe => 0, # paranoia rebuild => 0, }, -} #}}} +} -sub safe_git (&@) { #{{{ - # Start a child process safely without resorting /bin/sh. - # Return command output or success state (in scalar context). +sub genwrapper { + if ($config{test_receive}) { + require IkiWiki::Receive; + return IkiWiki::Receive::genwrapper(); + } + else { + return ""; + } +} - my ($error_handler, @cmdline) = @_; +# Loosely based on git-new-workdir from git contrib. +sub create_temp_working_dir ($$) { + my $rootdir = shift; + my $branch = shift; + my $working = "$rootdir/.git/ikiwiki-temp-working"; + remove_tree($working); + + foreach my $dir ("", ".git") { + if (!mkdir("$working/$dir")) { + error("Unable to create $working/$dir: $!"); + } + } + + # Hooks are deliberately not included: we will commit to the temporary + # branch that is used in the temporary working tree, and we don't want + # to run the post-commit hook there. + # + # logs/refs is not included because we don't use the reflog. + # remotes, rr-cache, svn are similarly excluded. + foreach my $link ("config", "refs", "objects", "info", "packed-refs") { + if (!symlink("../../$link", "$working/.git/$link")) { + error("Unable to create symlink $working/.git/$link: $!"); + } + } + + open (my $out, '>', "$working/.git/HEAD") or + error("failed to write $working.git/HEAD: $!"); + print $out "ref: refs/heads/$branch\n" or + error("failed to write $working.git/HEAD: $!"); + close $out or + error("failed to write $working.git/HEAD: $!"); + return $working; +} + +sub safe_git { + # Start a child process safely without resorting to /bin/sh. + # Returns command output (in list content) or success state + # (in scalar context), or runs the specified data handler. + + my %params = @_; my $pid = open my $OUT, "-|"; + error("Working directory not specified") unless defined $params{chdir}; error("Cannot fork: $!") if !defined $pid; if (!$pid) { # In child. # Git commands want to be in wc. - chdir $config{srcdir} - or error("Cannot chdir to $config{srcdir}: $!"); - exec @cmdline or error("Cannot exec '@cmdline': $!"); + if ($params{chdir} ne '.') { + chdir $params{chdir} + or error("cannot chdir to $params{chdir}: $!"); + } + + if ($params{stdout}) { + open(STDOUT, '>&', $params{stdout}) or error("Cannot reopen stdout: $!"); + } + + exec @{$params{cmdline}} or error("Cannot exec '@{$params{cmdline}}': $!"); } # In parent. + # git output is probably utf-8 encoded, but may contain + # other encodings or invalidly encoded stuff. So do not rely + # on the normal utf-8 IO layer, decode it by hand. + binmode($OUT); + my @lines; while (<$OUT>) { + $_=decode_utf8($_, 0); + chomp; - push @lines, $_; + + if (! defined $params{data_handler}) { + push @lines, $_; + } + else { + last unless $params{data_handler}->($_); + } } close $OUT; - $error_handler->("'@cmdline' failed: $!") if $? && $error_handler; + $params{error_handler}->("'@{$params{cmdline}}' failed: $!") if $? && $params{error_handler}; return wantarray ? @lines : ($? == 0); } # Convenient wrappers. -sub run_or_die ($@) { safe_git(\&error, @_) } -sub run_or_cry ($@) { safe_git(sub { warn @_ }, @_) } -sub run_or_non ($@) { safe_git(undef, @_) } -#}}} +sub run_or_die_in ($$@) { + my $dir = shift; + safe_git(chdir => $dir, error_handler => \&error, cmdline => \@_); +} +sub run_or_cry_in ($$@) { + my $dir = shift; + safe_git(chdir => $dir, error_handler => sub { warn @_ }, cmdline => \@_); +} +sub run_or_non_in ($$@) { + my $dir = shift; + safe_git(chdir => $dir, cmdline => \@_); +} + +sub ensure_committer ($) { + my $dir = shift; + + if (! length $ENV{GIT_AUTHOR_NAME} || ! length $ENV{GIT_COMMITTER_NAME}) { + my $name = join('', run_or_non_in($dir, "git", "config", "user.name")); + if (! length $name) { + run_or_die_in($dir, "git", "config", "user.name", "IkiWiki"); + } + } + + if (! length $ENV{GIT_AUTHOR_EMAIL} || ! length $ENV{GIT_COMMITTER_EMAIL}) { + my $email = join('', run_or_non_in($dir, "git", "config", "user.email")); + if (! length $email) { + run_or_die_in($dir, "git", "config", "user.email", "ikiwiki.info"); + } + } +} -sub merge_past ($$$) { #{{{ +sub merge_past ($$$) { # Unlike with Subversion, Git cannot make a 'svn merge -rN:M file'. # Git merge commands work with the committed changes, except in the # implicit case of '-m' of git checkout(1). So we should invent a @@ -163,6 +310,8 @@ sub merge_past ($$$) { #{{{ my @undo; # undo stack for cleanup in case of an error my $conflict; # file content with conflict markers + ensure_committer($config{srcdir}); + eval { # Hide local changes from Git by renaming the modified file. # Relative paths must be converted to absolute for renaming. @@ -181,30 +330,30 @@ sub merge_past ($$$) { #{{{ my $branch = "throw_away_${sha1}"; # supposed to be unique # Create a throw-away branch and rewind backward. - push @undo, sub { run_or_cry('git', 'branch', '-D', $branch) }; - run_or_die('git', 'branch', $branch, $sha1); + push @undo, sub { run_or_cry_in($config{srcdir}, 'git', 'branch', '-D', $branch) }; + run_or_die_in($config{srcdir}, 'git', 'branch', $branch, $sha1); # Switch to throw-away branch for the merge operation. push @undo, sub { - if (!run_or_cry('git', 'checkout', $config{gitmaster_branch})) { - run_or_cry('git', 'checkout','-f',$config{gitmaster_branch}); + if (!run_or_cry_in($config{srcdir}, 'git', 'checkout', $config{gitmaster_branch})) { + run_or_cry_in($config{srcdir}, 'git', 'checkout','-f',$config{gitmaster_branch}); } }; - run_or_die('git', 'checkout', $branch); + run_or_die_in($config{srcdir}, 'git', 'checkout', $branch); # Put the modified file in _this_ branch. rename($hidden, $target) or error("rename '$hidden' to '$target' failed: $!"); # _Silently_ commit all modifications in the current branch. - run_or_non('git', 'commit', '-m', $message, '-a'); + run_or_non_in($config{srcdir}, 'git', 'commit', '-m', $message, '-a'); # ... and re-switch to master. - run_or_die('git', 'checkout', $config{gitmaster_branch}); + run_or_die_in($config{srcdir}, 'git', 'checkout', $config{gitmaster_branch}); # Attempt to merge without complaining. - if (!run_or_non('git', 'pull', '--no-commit', '.', $branch)) { + if (!run_or_non_in($config{srcdir}, 'git', 'pull', '--no-commit', '.', $branch)) { $conflict = readfile($target); - run_or_die('git', 'reset', '--hard'); + run_or_die_in($config{srcdir}, 'git', 'reset', '--hard'); } }; my $failure = $@; @@ -218,17 +367,44 @@ sub merge_past ($$$) { #{{{ error("Git merge failed!\n$failure\n") if $failure; return $conflict; -} #}}} +} + +{ +my %prefix_cache; + +sub decode_git_file ($$) { + my $dir=shift; + my $file=shift; + + # git does not output utf-8 filenames, but instead + # double-quotes them with the utf-8 characters + # escaped as \nnn\nnn. + if ($file =~ m/^"(.*)"$/) { + ($file=$1) =~ s/\\([0-7]{1,3})/chr(oct($1))/eg; + } -sub parse_diff_tree ($@) { #{{{ + # strip prefix if in a subdir + if (! defined $prefix_cache{$dir}) { + ($prefix_cache{$dir}) = run_or_die_in($dir, 'git', 'rev-parse', '--show-prefix'); + if (! defined $prefix_cache{$dir}) { + $prefix_cache{$dir}=""; + } + } + $file =~ s/^\Q$prefix_cache{$dir}\E//; + + return decode("utf8", $file); +} +} + +sub parse_diff_tree ($$) { # Parse the raw diff tree chunk and return the info hash. # See git-diff-tree(1) for the syntax. - - my ($prefix, $dt_ref) = @_; + my $dir = shift; + my $dt_ref = shift; # End of stream? - return if !defined @{ $dt_ref } || - !defined @{ $dt_ref }[0] || !length @{ $dt_ref }[0]; + return if ! @{ $dt_ref } || + !defined $dt_ref->[0] || !length $dt_ref->[0]; my %ci; # Header line. @@ -258,8 +434,9 @@ sub parse_diff_tree ($@) { #{{{ $ci{ "${who}_epoch" } = $epoch; $ci{ "${who}_tz" } = $tz; - if ($name =~ m/^[^<]+\s+<([^@>]+)/) { - $ci{"${who}_username"} = $1; + if ($name =~ m/^([^<]+)\s+<([^@>]+)/) { + $ci{"${who}_name"} = $1; + $ci{"${who}_username"} = $2; } elsif ($name =~ m/^([^<]+)\s+<>$/) { $ci{"${who}_username"} = $1; @@ -291,6 +468,17 @@ sub parse_diff_tree ($@) { #{{{ } shift @{ $dt_ref } if $dt_ref->[0] =~ /^$/; + $ci{details} = [parse_changed_files($dir, $dt_ref)]; + + return \%ci; +} + +sub parse_changed_files ($$) { + my $dir = shift; + my $dt_ref = shift; + + my @files; + # Modified files. while (my $line = shift @{ $dt_ref }) { if ($line =~ m{^ @@ -307,15 +495,14 @@ sub parse_diff_tree ($@) { #{{{ my $sha1_to = shift(@tmp); my $status = shift(@tmp); - if ($file =~ m/^"(.*)"$/) { - ($file=$1) =~ s/\\([0-7]{1,3})/chr(oct($1))/eg; - } - $file =~ s/^\Q$prefix\E//; if (length $file) { - push @{ $ci{'details'} }, { - 'file' => decode_utf8($file), + push @files, { + 'file' => decode_git_file($dir, $file), 'sha1_from' => $sha1_from[0], 'sha1_to' => $sha1_to, + 'mode_from' => $mode_from[0], + 'mode_to' => $mode_to, + 'status' => $status, }; } next; @@ -323,104 +510,200 @@ sub parse_diff_tree ($@) { #{{{ last; } - return \%ci; -} #}}} + return @files; +} -sub git_commit_info ($;$) { #{{{ - # Return an array of commit info hashes of num commits (default: 1) +sub git_commit_info ($$;$) { + # Return an array of commit info hashes of num commits # starting from the given sha1sum. + my ($dir, $sha1, $num) = @_; - my ($sha1, $num) = @_; + my @opts; + push @opts, "--max-count=$num" if defined $num; - $num ||= 1; - - my @raw_lines = run_or_die('git', 'log', "--max-count=$num", + my @raw_lines = run_or_die_in($dir, 'git', 'log', @opts, '--pretty=raw', '--raw', '--abbrev=40', '--always', '-c', - '-r', $sha1, '--', '.'); - my ($prefix) = run_or_die('git', 'rev-parse', '--show-prefix'); + '-r', $sha1, '--no-renames', '--', '.'); my @ci; - while (my $parsed = parse_diff_tree(($prefix or ""), \@raw_lines)) { + while (my $parsed = parse_diff_tree($dir, \@raw_lines)) { push @ci, $parsed; } warn "Cannot parse commit info for '$sha1' commit" if !@ci; return wantarray ? @ci : $ci[0]; -} #}}} +} + +sub rcs_find_changes ($) { + my $oldrev=shift; + + # Note that git log will sometimes show files being added that + # don't exist. Particularly, git merge -s ours can result in a + # merge commit where some files were not really added. + # This is why the code below verifies that the files really + # exist. + my @raw_lines = run_or_die_in($config{srcdir}, 'git', 'log', + '--pretty=raw', '--raw', '--abbrev=40', '--always', '-c', + '--no-renames', , '--reverse', + '-r', "$oldrev..HEAD", '--', '.'); + + # Due to --reverse, we see changes in chronological order. + my %changed; + my %deleted; + my $nullsha = 0 x 40; + my $newrev=$oldrev; + while (my $ci = parse_diff_tree($config{srcdir}, \@raw_lines)) { + $newrev=$ci->{sha1}; + foreach my $i (@{$ci->{details}}) { + my $file=$i->{file}; + if ($i->{sha1_to} eq $nullsha) { + if (! -e "$config{srcdir}/$file") { + delete $changed{$file}; + $deleted{$file}=1; + } + } + else { + if (-e "$config{srcdir}/$file") { + delete $deleted{$file}; + $changed{$file}=1; + } + } + } + } -sub git_sha1 (;$) { #{{{ - # Return head sha1sum (of given file). + return (\%changed, \%deleted, $newrev); +} - my $file = shift || q{--}; +sub git_sha1_file ($$) { + my $dir=shift; + my $file=shift; + return git_sha1($dir, "--", $file); +} +sub git_sha1 ($@) { + my $dir = shift; # Ignore error since a non-existing file might be given. - my ($sha1) = run_or_non('git', 'rev-list', '--max-count=1', 'HEAD', - '--', $file); - if ($sha1) { + my ($sha1) = run_or_non_in($dir, 'git', 'rev-list', '--max-count=1', 'HEAD', + '--', @_); + if (defined $sha1) { ($sha1) = $sha1 =~ m/($sha1_pattern)/; # sha1 is untainted now - } else { debug("Empty sha1sum for '$file'.") } - return defined $sha1 ? $sha1 : q{}; -} #}}} + } + return defined $sha1 ? $sha1 : ''; +} + +sub rcs_get_current_rev () { + return git_sha1($config{srcdir}); +} -sub rcs_update () { #{{{ +sub rcs_update () { # Update working directory. + ensure_committer($config{srcdir}); if (length $config{gitorigin_branch}) { - run_or_cry('git', 'pull', $config{gitorigin_branch}); + run_or_cry_in($config{srcdir}, 'git', 'pull', '--prune', $config{gitorigin_branch}); } -} #}}} +} -sub rcs_prepedit ($) { #{{{ +sub rcs_prepedit ($) { # Return the commit sha1sum of the file when editing begins. # This will be later used in rcs_commit if a merge is required. - my ($file) = @_; - return git_sha1($file); -} #}}} + return git_sha1_file($config{srcdir}, $file); +} -sub rcs_commit ($$$;$$) { #{{{ +sub rcs_commit (@) { # Try to commit the page; returns undef on _success_ and # a version of the page with the rcs's conflict markers on # failure. - - my ($file, $message, $rcstoken, $user, $ipaddr) = @_; + my %params=@_; # Check to see if the page has been changed by someone else since # rcs_prepedit was called. - my $cur = git_sha1($file); - my ($prev) = $rcstoken =~ /^($sha1_pattern)$/; # untaint + my $cur = git_sha1_file($config{srcdir}, $params{file}); + my $prev; + if (defined $params{token}) { + ($prev) = $params{token} =~ /^($sha1_pattern)$/; # untaint + } if (defined $cur && defined $prev && $cur ne $prev) { - my $conflict = merge_past($prev, $file, $dummy_commit_msg); + my $conflict = merge_past($prev, $params{file}, $dummy_commit_msg); return $conflict if defined $conflict; } - rcs_add($file); - return rcs_commit_staged($message, $user, $ipaddr); -} #}}} + return rcs_commit_helper(@_); +} -sub rcs_commit_staged ($$$) { +sub rcs_commit_staged (@) { # Commits all staged changes. Changes can be staged using rcs_add, # rcs_remove, and rcs_rename. - my ($message, $user, $ipaddr)=@_; + return rcs_commit_helper(@_); +} - # Set the commit author and email to the web committer. +sub rcs_commit_helper (@) { + my %params=@_; + my %env=%ENV; - if (defined $user || defined $ipaddr) { - my $u=defined $user ? $user : $ipaddr; - $ENV{GIT_AUTHOR_NAME}=$u; - $ENV{GIT_AUTHOR_EMAIL}="$u\@web"; + + if (defined $params{session}) { + # Set the commit author and email based on web session info. + my $u; + if (defined $params{session}->param("name")) { + $u=$params{session}->param("name"); + } + elsif (defined $params{session}->remote_addr()) { + $u=$params{session}->remote_addr(); + } + if (length $u) { + $u=encode_utf8(IkiWiki::cloak($u)); + $ENV{GIT_AUTHOR_NAME}=$u; + } + else { + $u = 'anonymous'; + } + if (defined $params{session}->param("nickname")) { + $u=encode_utf8($params{session}->param("nickname")); + $u=~s/\s+/_/g; + $u=~s/[^-_0-9[:alnum:]]+//g; + } + if (length $u) { + $ENV{GIT_AUTHOR_EMAIL}="$u\@web"; + } + else { + $ENV{GIT_AUTHOR_EMAIL}='anonymous@web'; + } } - # git commit returns non-zero if file has not been really changed. - # so we should ignore its exit status (hence run_or_non). - $message = IkiWiki::possibly_foolish_untaint($message); - if (run_or_non('git', 'commit', '--cleanup=verbatim', - '-q', '-m', $message)) { + ensure_committer($config{srcdir}); + + $params{message} = IkiWiki::possibly_foolish_untaint($params{message}); + my @opts; + if ($params{message} !~ /\S/) { + # Force git to allow empty commit messages. + # (If this version of git supports it.) + my ($version)=`git --version` =~ /git version (.*)/; + if ($version ge "1.7.8") { + push @opts, "--allow-empty-message", "--no-edit"; + } + if ($version ge "1.7.2") { + push @opts, "--allow-empty-message"; + } + elsif ($version ge "1.5.4") { + push @opts, '--cleanup=verbatim'; + } + else { + $params{message}.="."; + } + } + if (exists $params{file}) { + push @opts, '--', $params{file}; + } + # git commit returns non-zero if nothing really changed. + # So we should ignore its exit status (hence run_or_non_in). + if (run_or_non_in($config{srcdir}, 'git', 'commit', '-m', $params{message}, '-q', @opts)) { if (length $config{gitorigin_branch}) { - run_or_cry('git', 'push', $config{gitorigin_branch}); + run_or_cry_in($config{srcdir}, 'git', 'push', $config{gitorigin_branch}, $config{gitmaster_branch}); } } @@ -428,29 +711,32 @@ sub rcs_commit_staged ($$$) { return undef; # success } -sub rcs_add ($) { # {{{ +sub rcs_add ($) { # Add file to archive. my ($file) = @_; - run_or_cry('git', 'add', $file); -} #}}} + ensure_committer($config{srcdir}); + run_or_cry_in($config{srcdir}, 'git', 'add', '--', $file); +} -sub rcs_remove ($) { # {{{ +sub rcs_remove ($) { # Remove file from archive. my ($file) = @_; - run_or_cry('git', 'rm', '-f', $file); -} #}}} + ensure_committer($config{srcdir}); + run_or_cry_in($config{srcdir}, 'git', 'rm', '-f', '--', $file); +} -sub rcs_rename ($$) { # {{{ +sub rcs_rename ($$) { my ($src, $dest) = @_; - run_or_cry('git', 'mv', '-f', $src, $dest); -} #}}} + ensure_committer($config{srcdir}); + run_or_cry_in($config{srcdir}, 'git', 'mv', '-f', '--', $src, $dest); +} -sub rcs_recentchanges ($) { #{{{ +sub rcs_recentchanges ($) { # List of recent changes. my ($num) = @_; @@ -459,7 +745,7 @@ sub rcs_recentchanges ($) { #{{{ error($@) if $@; my @rets; - foreach my $ci (git_commit_info('HEAD', $num)) { + foreach my $ci (git_commit_info($config{srcdir}, 'HEAD', $num || 1)) { # Skip redundant commits. next if ($ci->{'comment'} && @{$ci->{'comment'}}[0] eq $dummy_commit_msg); @@ -471,12 +757,16 @@ sub rcs_recentchanges ($) { #{{{ my @pages; foreach my $detail (@{ $ci->{'details'} }) { my $file = $detail->{'file'}; + my $efile = join('/', + map { uri_escape_utf8($_) } split('/', $file) + ); - my $diffurl = $config{'diffurl'}; - $diffurl =~ s/\[\[file\]\]/$file/go; + my $diffurl = defined $config{'diffurl'} ? $config{'diffurl'} : ""; + $diffurl =~ s/\[\[file\]\]/$efile/go; $diffurl =~ s/\[\[sha1_parent\]\]/$ci->{'parent'}/go; $diffurl =~ s/\[\[sha1_from\]\]/$detail->{'sha1_from'}/go; $diffurl =~ s/\[\[sha1_to\]\]/$detail->{'sha1_to'}/go; + $diffurl =~ s/\[\[sha1_commit\]\]/$sha1/go; push @pages, { page => pagename($file), @@ -494,7 +784,16 @@ sub rcs_recentchanges ($) { #{{{ my $user=$ci->{'author_username'}; my $web_commit = ($ci->{'author'} =~ /\@web>/); - + my $nickname; + + # Set nickname only if a non-url author_username is available, + # and author_name is an url. + if ($user !~ /:\/\// && defined $ci->{'author_name'} && + $ci->{'author_name'} =~ /:\/\//) { + $nickname=$user; + $user=$ci->{'author_name'}; + } + # compatability code for old web commit messages if (! $web_commit && defined $messages[0] && @@ -507,6 +806,7 @@ sub rcs_recentchanges ($) { #{{{ push @rets, { rev => $sha1, user => $user, + nickname => $nickname, committype => $web_commit ? "web" : "git", when => $when, message => [@messages], @@ -517,36 +817,292 @@ sub rcs_recentchanges ($) { #{{{ } return @rets; -} #}}} +} -sub rcs_diff ($) { #{{{ +sub rcs_diff ($;$) { my $rev=shift; + my $maxlines=shift; my ($sha1) = $rev =~ /^($sha1_pattern)$/; # untaint my @lines; - foreach my $line (run_or_non("git", "show", $sha1)) { - if (@lines || $line=~/^diff --git/) { - push @lines, $line."\n"; - } - } + my $addlines=sub { + my $line=shift; + return if defined $maxlines && @lines == $maxlines; + push @lines, $line."\n" + if (@lines || $line=~/^diff --git/); + return 1; + }; + safe_git( + chdir => $config{srcdir}, + error_handler => undef, + data_handler => $addlines, + cmdline => ["git", "show", $sha1], + ); if (wantarray) { return @lines; } else { return join("", @lines); } -} #}}} +} + +{ +my %time_cache; + +sub findtimes ($$) { + my $file=shift; + my $id=shift; # 0 = mtime ; 1 = ctime + + if (! keys %time_cache) { + my $date; + foreach my $line (run_or_die_in($config{srcdir}, 'git', 'log', + '--pretty=format:%at', + '--name-only', '--relative')) { + if (! defined $date && $line =~ /^(\d+)$/) { + $date=$line; + } + elsif (! length $line) { + $date=undef; + } + else { + my $f=decode_git_file($config{srcdir}, $line); + + if (! $time_cache{$f}) { + $time_cache{$f}[0]=$date; # mtime + } + $time_cache{$f}[1]=$date; # ctime + } + } + } + + return exists $time_cache{$file} ? $time_cache{$file}[$id] : 0; +} + +} + +sub rcs_getctime ($) { + my $file=shift; + + return findtimes($file, 1); +} -sub rcs_getctime ($) { #{{{ +sub rcs_getmtime ($) { my $file=shift; - # Remove srcdir prefix - $file =~ s/^\Q$config{srcdir}\E\/?//; - my $sha1 = git_sha1($file); - my $ci = git_commit_info($sha1); - my $ctime = $ci->{'author_epoch'}; - debug("ctime for '$file': ". localtime($ctime)); + return findtimes($file, 0); +} + +{ +my $ret; +sub git_find_root { + # The wiki may not be the only thing in the git repo. + # Determine if it is in a subdirectory by examining the srcdir, + # and its parents, looking for the .git directory. + + return @$ret if defined $ret; + + my $subdir=""; + my $dir=$config{srcdir}; + while (! -d "$dir/.git") { + $subdir=IkiWiki::basename($dir)."/".$subdir; + $dir=IkiWiki::dirname($dir); + if (! length $dir) { + error("cannot determine root of git repo"); + } + } + + $ret=[$subdir, $dir]; + return @$ret; +} + +} + +sub git_parse_changes ($$@) { + my $dir = shift; + my $reverted = shift; + my @changes = @_; + + my ($subdir, $rootdir) = git_find_root(); + my @rets; + foreach my $ci (@changes) { + foreach my $detail (@{ $ci->{'details'} }) { + my $file = $detail->{'file'}; + + # check that all changed files are in the subdir + if (length $subdir && + ! ($file =~ s/^\Q$subdir\E//)) { + error sprintf(gettext("you are not allowed to change %s"), $file); + } + + my ($action, $mode, $path); + if ($detail->{'status'} =~ /^[M]+\d*$/) { + $action="change"; + $mode=$detail->{'mode_to'}; + } + elsif ($detail->{'status'} =~ /^[AM]+\d*$/) { + $action= $reverted ? "remove" : "add"; + $mode=$detail->{'mode_to'}; + } + elsif ($detail->{'status'} =~ /^[DAM]+\d*/) { + $action= $reverted ? "add" : "remove"; + $mode=$detail->{'mode_from'}; + } + else { + error "unknown status ".$detail->{'status'}; + } + + # test that the file mode is ok + if ($mode !~ /^100[64][64][64]$/) { + error sprintf(gettext("you cannot act on a file with mode %s"), $mode); + } + if ($action eq "change") { + if ($detail->{'mode_from'} ne $detail->{'mode_to'}) { + error gettext("you are not allowed to change file modes"); + } + } + + # extract attachment to temp file + if (($action eq 'add' || $action eq 'change') && + ! pagetype($file)) { + eval q{use File::Temp}; + die $@ if $@; + my $fh; + ($fh, $path)=File::Temp::tempfile(undef, UNLINK => 1); + safe_git( + chdir => $dir, + error_handler => sub { error("failed writing temp file '$path': ".shift."."); }, + stdout => $fh, + cmdline => ['git', 'show', $detail->{sha1_to}], + ); + } + + push @rets, { + file => $file, + action => $action, + path => $path, + }; + } + } + + return @rets; +} + +sub rcs_receive () { + my @rets; + while (<>) { + chomp; + my ($oldrev, $newrev, $refname) = split(' ', $_, 3); + + # only allow changes to gitmaster_branch + if ($refname !~ /^refs\/heads\/\Q$config{gitmaster_branch}\E$/) { + error sprintf(gettext("you are not allowed to change %s"), $refname); + } + + # Avoid chdir when running git here, because the changes + # are in the master git repo, not the srcdir repo. + # (Also, if a subdir is involved, we don't want to chdir to + # it and only see changes in it.) + # The pre-receive hook already puts us in the right place. + push @rets, git_parse_changes('.', 0, git_commit_info('.', $oldrev."..".$newrev)); + } + + return reverse @rets; +} + +sub rcs_preprevert ($) { + my $rev=shift; + my ($sha1) = $rev =~ /^($sha1_pattern)$/; # untaint + + my @undo; # undo stack for cleanup in case of an error + + # Examine changes from root of git repo, not from any subdir, + # in order to see all changes. + my ($subdir, $rootdir) = git_find_root(); + ensure_committer($rootdir); + + # preserve indentation of previous in_git_dir code for now + do { + my @commits=git_commit_info($rootdir, $sha1, 1); + + if (! @commits) { + error "unknown commit"; # just in case + } - return $ctime; -} #}}} + # git revert will fail on merge commits. Add a nice message. + if (exists $commits[0]->{parents} && + @{$commits[0]->{parents}} > 1) { + error gettext("you are not allowed to revert a merge"); + } + + # Due to the presence of rename-detection, we cannot actually + # see what will happen in a revert without trying it. + # But we can guess, which is enough to rule out most changes + # that we won't allow reverting. + git_parse_changes($rootdir, 1, @commits); + + my $failure; + my @ret; + eval { + my $branch = "ikiwiki_revert_${sha1}"; # supposed to be unique + + push @undo, sub { + run_or_cry_in($rootdir, 'git', 'branch', '-D', $branch) if $failure; + }; + if (run_or_non_in($rootdir, 'git', 'rev-parse', '--quiet', '--verify', $branch)) { + run_or_non_in($rootdir, 'git', 'branch', '-D', $branch); + } + run_or_die_in($rootdir, 'git', 'branch', $branch, $config{gitmaster_branch}); + + my $working = create_temp_working_dir($rootdir, $branch); + + push @undo, sub { + remove_tree($working); + }; + + run_or_die_in($working, 'git', 'checkout', '--quiet', '--force', $branch); + run_or_die_in($working, 'git', 'revert', '--no-commit', $sha1); + run_or_die_in($working, 'git', 'commit', '-m', "revert $sha1", '-a'); + + my @raw_lines; + @raw_lines = run_or_die_in($rootdir, 'git', 'diff', '--pretty=raw', + '--raw', '--abbrev=40', '--always', '--no-renames', + "..${branch}"); + + my $ci = { + details => [parse_changed_files($rootdir, \@raw_lines)], + }; + + @ret = git_parse_changes($rootdir, 0, $ci); + }; + $failure = $@; + + # Process undo stack (in reverse order). By policy cleanup + # actions should normally print a warning on failure. + while (my $handle = pop @undo) { + $handle->(); + } + + if ($failure) { + my $message = sprintf(gettext("Failed to revert commit %s"), $sha1); + error("$message\n$failure\n"); + } + return @ret; + }; +} + +sub rcs_revert ($) { + # Try to revert the given rev; returns undef on _success_. + my $rev = shift; + my ($sha1) = $rev =~ /^($sha1_pattern)$/; # untaint + + ensure_committer($config{srcdir}); + + if (run_or_non_in($config{srcdir}, 'git', 'cherry-pick', '--no-commit', "ikiwiki_revert_$sha1")) { + return undef; + } + else { + run_or_non_in($config{srcdir}, 'git', 'branch', '-D', "ikiwiki_revert_$sha1"); + return sprintf(gettext("Failed to revert commit %s"), $sha1); + } +} 1