X-Git-Url: http://git.vanrenterghem.biz/git.ikiwiki.info.git/blobdiff_plain/92065444d982a443d3862f9ce5094bd32faffb85..8cac2ac23eac0026faf4054c1ffda459be4a2bd3:/IkiWiki/Rcs/git.pm diff --git a/IkiWiki/Rcs/git.pm b/IkiWiki/Rcs/git.pm index a156f0b4e..036900887 100644 --- a/IkiWiki/Rcs/git.pm +++ b/IkiWiki/Rcs/git.pm @@ -8,11 +8,8 @@ use open qw{:utf8 :std}; package IkiWiki; -my $origin_branch = 'origin'; # Git ref for main repository -my $master_branch = 'master'; # working branch 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 -my $web_commit_msg = qr/^web commit (by (\w+)|from (\d+\.\d+\.\d+\.\d+)):?(.*)/; sub _safe_git (&@) { #{{{ # Start a child process safely without resorting /bin/sh. @@ -26,8 +23,6 @@ sub _safe_git (&@) { #{{{ if (!$pid) { # In child. - open STDERR, ">&STDOUT" - or error("Cannot dup STDOUT: $!"); # Git commands want to be in wc. chdir $config{srcdir} or error("Cannot chdir to $config{srcdir}: $!"); @@ -43,12 +38,12 @@ sub _safe_git (&@) { #{{{ close $OUT; - ($error_handler || sub { })->("'@cmdline' failed: $!") if $?; + $error_handler->("'@cmdline' failed: $!") if $? && $error_handler; return wantarray ? @lines : ($? == 0); } # Convenient wrappers. -sub run_or_die ($@) { _safe_git(\&IkiWiki::error, @_) } +sub run_or_die ($@) { _safe_git(\&error, @_) } sub run_or_cry ($@) { _safe_git(sub { warn @_ }, @_) } sub run_or_non ($@) { _safe_git(undef, @_) } #}}} @@ -56,7 +51,7 @@ sub run_or_non ($@) { _safe_git(undef, @_) } 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 + # implicit case of '-m' of git checkout(1). So we should invent a # kludge here. In principle, we need to create a throw-away branch # in preparing for the merge itself. Since branches are cheap (and # branching is fast), this shouldn't cost high. @@ -65,7 +60,7 @@ sub _merge_past ($$$) { #{{{ # possible approach to get rid of this situation could be that we first # make a temporary commit in the master branch and later restore the # initial state (this is possible since Git has the ability to undo a - # commit, i.e. 'git-reset --soft HEAD^'). The method can be summarized + # commit, i.e. 'git reset --soft HEAD^'). The method can be summarized # as follows: # # - create a diff of HEAD:current-sha1 @@ -108,30 +103,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('git', 'branch', '-D', $branch) }; + run_or_die('git', 'branch', $branch, $sha1); # Switch to throw-away branch for the merge operation. push @undo, sub { - if (!run_or_cry('git-checkout', $master_branch)) { - run_or_cry('git-checkout','-f',$master_branch); + if (!run_or_cry('git', 'checkout', $config{gitmaster_branch})) { + run_or_cry('git', 'checkout','-f',$config{gitmaster_branch}); } }; - run_or_die('git-checkout', $branch); + run_or_die('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('git', 'commit', '-m', $message, '-a'); # ... and re-switch to master. - run_or_die('git-checkout', $master_branch); + run_or_die('git', 'checkout', $config{gitmaster_branch}); # Attempt to merge without complaining. - if (!run_or_non('git-pull', '--no-commit', '.', $branch)) { + if (!run_or_non('git', 'pull', '--no-commit', '.', $branch)) { $conflict = readfile($target); - run_or_die('git-reset', '--hard'); + run_or_die('git', 'reset', '--hard'); } }; my $failure = $@; @@ -147,34 +142,37 @@ sub _merge_past ($$$) { #{{{ return $conflict; } #}}} -sub _parse_diff_tree (@) { #{{{ +sub _parse_diff_tree ($@) { #{{{ # Parse the raw diff tree chunk and return the info hash. # See git-diff-tree(1) for the syntax. - my ($dt_ref) = @_; + my ($prefix, $dt_ref) = @_; # End of stream? - return if !defined @{ $dt_ref } || !length @{ $dt_ref }[0]; + return if !defined @{ $dt_ref } || + !defined @{ $dt_ref }[0] || !length @{ $dt_ref }[0]; my %ci; # Header line. - HEADER: while (my $line = shift @{ $dt_ref }) { + while (my $line = shift @{ $dt_ref }) { return if $line !~ m/^(.+) ($sha1_pattern)/; - my $sha1 = $1; + my $sha1 = $2; $ci{'sha1'} = $sha1; - last HEADER; + last; } # Identification lines for the commit. - IDENT: while (my $line = shift @{ $dt_ref }) { + while (my $line = shift @{ $dt_ref }) { # Regexps are semi-stolen from gitweb.cgi. if ($line =~ m/^tree ([0-9a-fA-F]{40})$/) { $ci{'tree'} = $1; - } elsif ($line =~ m/^parent ([0-9a-fA-F]{40})$/) { + } + elsif ($line =~ m/^parent ([0-9a-fA-F]{40})$/) { # XXX: collecting in reverse order push @{ $ci{'parents'} }, $1; - } elsif ($line =~ m/^(author|committer) (.*) ([0-9]+) (.*)$/) { + } + elsif ($line =~ m/^(author|committer) (.*) ([0-9]+) (.*)$/) { my ($who, $name, $epoch, $tz) = ($1, $2, $3, $4 ); @@ -182,83 +180,91 @@ sub _parse_diff_tree (@) { #{{{ $ci{ "${who}_epoch" } = $epoch; $ci{ "${who}_tz" } = $tz; - if ($name =~ m/^([^<]+) <([^@]+)/) { + if ($name =~ m/^([^<]+) <([^@>]+)/) { my ($fullname, $username) = ($1, $2); $ci{"${who}_fullname"} = $fullname; $ci{"${who}_username"} = $username; - } else { + } + else { $ci{"${who}_fullname"} = $ci{"${who}_username"} = $name; } - } elsif ($line =~ m/^$/) { + } + elsif ($line =~ m/^$/) { # Trailing empty line signals next section. - last IDENT; + last; } } - error("No 'tree' or 'parents' seen in diff-tree output") - if !defined $ci{'tree'} || !defined $ci{'parents'}; + debug("No 'tree' seen in diff-tree output") if !defined $ci{'tree'}; - $ci{'parent'} = @{ $ci{'parents'} }[0]; + if (defined $ci{'parents'}) { + $ci{'parent'} = @{ $ci{'parents'} }[0]; + } + else { + $ci{'parent'} = 0 x 40; + } # Commit message. - COMMENT: while (my $line = shift @{ $dt_ref }) { + while (my $line = shift @{ $dt_ref }) { if ($line =~ m/^$/) { # Trailing empty line signals next section. - last COMMENT; + last; }; $line =~ s/^ //; push @{ $ci{'comment'} }, $line; } # Modified files. - FILE: while (my $line = shift @{ $dt_ref }) { - if ($line =~ m{^: - ([0-7]{6})[ ] # from mode - ([0-7]{6})[ ] # to mode - ($sha1_pattern)[ ] # from sha1 - ($sha1_pattern)[ ] # to sha1 - (.) # status - ([0-9]{0,3})\t # similarity - (.*) # file + while (my $line = shift @{ $dt_ref }) { + if ($line =~ m{^ + (:+) # number of parents + ([^\t]+)\t # modes, sha1, status + (.*) # file names $}xo) { - my ($sha1_from, $sha1_to, $file) = - ($3, $4, $7 ); + my $num_parents = length $1; + my @tmp = split(" ", $2); + my ($file, $file_to) = split("\t", $3); + my @mode_from = splice(@tmp, 0, $num_parents); + my $mode_to = shift(@tmp); + my @sha1_from = splice(@tmp, 0, $num_parents); + 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), - 'sha1_from' => $sha1_from, + 'sha1_from' => $sha1_from[0], 'sha1_to' => $sha1_to, }; } - next FILE; + next; }; - last FILE; + last; } - warn "No detail in diff-tree output" if !defined $ci{'details'}; - return \%ci; } #}}} -sub git_commit_info (;$$) { #{{{ +sub git_commit_info ($;$) { #{{{ # Return an array of commit info hashes of num commits (default: 1) - # starting from the given sha1sum (default: HEAD). + # starting from the given sha1sum. my ($sha1, $num) = @_; $num ||= 1; - my @raw_lines = - run_or_die(qq{git-rev-list --max-count=$num $sha1 | - git-diff-tree --stdin --pretty=raw -M -r}); + my @raw_lines = run_or_die('git', 'log', "--max-count=$num", + '--pretty=raw', '--raw', '--abbrev=40', '--always', '-c', + '-r', $sha1, '--', '.'); + my ($prefix) = run_or_die('git', 'rev-parse', '--show-prefix'); my @ci; - while (my $parsed = _parse_diff_tree(\@raw_lines)) { + while (my $parsed = _parse_diff_tree(($prefix or ""), \@raw_lines)) { push @ci, $parsed; } @@ -273,7 +279,8 @@ sub git_sha1 (;$) { #{{{ my $file = shift || q{--}; # Ignore error since a non-existing file might be given. - my ($sha1) = run_or_non('git-rev-list', '--max-count=1', 'HEAD', $file); + my ($sha1) = run_or_non('git', 'rev-list', '--max-count=1', 'HEAD', + '--', $file); if ($sha1) { ($sha1) = $sha1 =~ m/($sha1_pattern)/; # sha1 is untainted now } else { debug("Empty sha1sum for '$file'.") } @@ -283,7 +290,9 @@ sub git_sha1 (;$) { #{{{ sub rcs_update () { #{{{ # Update working directory. - run_or_cry('git-pull', $origin_branch); + if (length $config{gitorigin_branch}) { + run_or_cry('git', 'pull', $config{gitorigin_branch}); + } } #}}} sub rcs_prepedit ($) { #{{{ @@ -295,19 +304,21 @@ sub rcs_prepedit ($) { #{{{ return git_sha1($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) = @_; + my ($file, $message, $rcstoken, $user, $ipaddr) = @_; - # XXX: Wiki directory is in the unlocked state when starting this - # action. But it takes time for a Git process to finish its job - # (especially if a merge required), so we must re-lock to prevent - # race conditions. Only when the time of the real commit action - # (i.e. git-push(1)) comes, we'll unlock the directory. - lockwiki(); + if (defined $user) { + $message = "web commit by $user" . + (length $message ? ": $message" : ""); + } + elsif (defined $ipaddr) { + $message = "web commit from $ipaddr" . + (length $message ? ": $message" : ""); + } # Check to see if the page has been changed by someone else since # rcs_prepedit was called. @@ -319,12 +330,13 @@ sub rcs_commit ($$$) { #{{{ return $conflict if defined $conflict; } - # git-commit(1) returns non-zero if file has not been really changed. + # git commit returns non-zero if file has not been really changed. # so we should ignore its exit status (hence run_or_non). $message = possibly_foolish_untaint($message); - if (run_or_non('git-commit', '-m', $message, '-i', $file)) { - unlockwiki(); - run_or_cry('git-push', $origin_branch); + if (run_or_non('git', 'commit', '-q', '-m', $message, '-i', $file)) { + if (length $config{gitorigin_branch}) { + run_or_cry('git', 'push', $config{gitorigin_branch}); + } } return undef; # success @@ -335,7 +347,7 @@ sub rcs_add ($) { # {{{ my ($file) = @_; - run_or_cry('git-add', $file); + run_or_cry('git', 'add', $file); } #}}} sub rcs_recentchanges ($) { #{{{ @@ -343,42 +355,47 @@ sub rcs_recentchanges ($) { #{{{ my ($num) = @_; - eval q{use CGI 'escapeHTML'}; eval q{use Date::Parse}; + error($@) if $@; - my ($sha1, $type, $when, $diffurl, $user, @pages, @message, @rets); - INFO: foreach my $ci (git_commit_info('HEAD', $num)) { - my $title = @{ $ci->{'comment'} }[0]; - + my @rets; + foreach my $ci (git_commit_info('HEAD', $num)) { # Skip redundant commits. - next INFO if ($title eq $dummy_commit_msg); + next if (@{$ci->{'comment'}}[0] eq $dummy_commit_msg); - $sha1 = $ci->{'sha1'}; - $type = "web"; - $when = time - $ci->{'author_epoch'}; + my ($sha1, $when) = ( + $ci->{'sha1'}, + $ci->{'author_epoch'} + ); - foreach my $bit (@{ $ci->{'details'} }) { - my $diffurl = $config{'diffurl'}; - my $file = $bit->{'file'}; + my (@pages, @messages); + foreach my $detail (@{ $ci->{'details'} }) { + my $file = $detail->{'file'}; + my $diffurl = $config{'diffurl'}; $diffurl =~ s/\[\[file\]\]/$file/go; $diffurl =~ s/\[\[sha1_parent\]\]/$ci->{'parent'}/go; - $diffurl =~ s/\[\[sha1_from\]\]/$bit->{'sha1_from'}/go; - $diffurl =~ s/\[\[sha1_to\]\]/$bit->{'sha1_to'}/go; + $diffurl =~ s/\[\[sha1_from\]\]/$detail->{'sha1_from'}/go; + $diffurl =~ s/\[\[sha1_to\]\]/$detail->{'sha1_to'}/go; push @pages, { page => pagename($file), diffurl => $diffurl, - }, + }; } - push @message, { line => escapeHTML($title) }; + push @messages, { line => $_ } foreach grep { + ! m/^ *(signed[ \-]off[ \-]by[ :]|acked[ \-]by[ :]|cc[ :])/i + } @{$ci->{'comment'}}; + + my ($user, $type) = (q{}, "web"); - if (defined $message[0] && - $message[0]->{line} =~ m/$web_commit_msg/) { - $user=defined $2 ? "$2" : "$3"; - $message[0]->{line}=$4; - } else { + if (defined $messages[0] && + $messages[0]->{line} =~ m/$config{web_commit_regexp}/) { + $user = defined $2 ? "$2" : "$3"; + $messages[0]->{line} = $4; + } + else { $type ="git"; $user = $ci->{'author_username'}; } @@ -388,96 +405,42 @@ sub rcs_recentchanges ($) { #{{{ user => $user, committype => $type, when => $when, - message => [@message], + message => [@messages], pages => [@pages], } if @pages; - $sha1 = $type = $when = $diffurl = $user = undef; - @pages = @message = (); + last if @rets >= $num; } return @rets; } #}}} -sub rcs_notify () { #{{{ - # Send notification mail to subscribed users. - # - # In usual Git usage, hooks/update script is presumed to send - # notification mails (see git-receive-pack(1)). But we prefer - # hooks/post-update to support IkiWiki commits coming from a - # cloned repository (through command line) because post-update - # is called _after_ each ref in repository is updated (update - # hook is called _before_ the repository is updated). Since - # post-update hook does not accept command line arguments, we - # don't have an $ENV variable in this function. - # - # Here, we rely on a simple fact: we can extract all parts of the - # notification content by parsing the "HEAD" commit (which also - # triggers a refresh of IkiWiki pages) and we can obtain the diff - # by comparing HEAD and HEAD^ (the previous commit). - - my $sha1 = 'HEAD'; # the commit which triggers this action - - my $ci = git_commit_info($sha1); - return if !defined $ci; - - my @changed_pages = map { $_->{'file'} } @{ $ci->{'details'} }; - - my ($user, $message); - if (@{ $ci->{'comment'} }[0] =~ m/$web_commit_msg/) { - $user = defined $2 ? "$2" : "$3"; - $message = $4; - } else { - $user = $ci->{'author_username'}; - $message = join "\n", @{ $ci->{'comment'} }; +sub rcs_diff ($) { #{{{ + my $rev=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"; + } } - - require IkiWiki::UserInfo; - my @email_recipients = commit_notify_list($user, @changed_pages); - return if !@email_recipients; - - # TODO: if a commit spans multiple pages, this will send - # subscribers a diff that might contain pages they did not - # sign up for. Should separate the diff per page and - # reassemble into one mail with just the pages subscribed to. - my $diff = join "\n", run_or_die('git-diff', "${sha1}^", $sha1); - - my $subject = "$config{wikiname} update of "; - if (@changed_pages > 2) { - $subject .= "$changed_pages[0] $changed_pages[1] etc"; - } else { - $subject .= join " ", @changed_pages; + if (wantarray) { + return @lines; } - $subject .= " by $user"; - - my $template = template("notifymail.tmpl"); - $template->param( - wikiname => $config{wikiname}, - diff => $diff, - user => $user, - message => $message, - ); - - eval q{use Mail::Sendmail}; - foreach my $email (@email_recipients) { - sendmail( - To => $email, - From => "$config{wikiname} <$config{adminemail}>", - Subject => $subject, - Message => $template->output, - ) or error("Failed to send update notification mail: $!"); + else { + return join("", @lines); } } #}}} sub rcs_getctime ($) { #{{{ - # Get the ctime of file. - - my ($file) = @_; + 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) . "\n"); + debug("ctime for '$file': ". localtime($ctime)); return $ctime; } #}}}