The branch, PHP_POST_RECEIVE on karma.git has been created
at 5d58ad7ac1700df5ad7d9bf50b73b80b71ce9844 (commit)
-- Log ----------------------------------------
commit 5d58ad7ac1700df5ad7d9bf50b73b80b71ce9844
Author: Alexander Moskaliov <ir...@php.net>
Date: Sat Mar 3 16:46:15 2012 +0400
Start rewrite post-receive on php
diff --git a/hooks/post-receive b/hooks/post-receive
index 3a45616..5576fe4 100755
--- a/hooks/post-receive
+++ b/hooks/post-receive
@@ -1,754 +1,43 @@
-#!/bin/sh
-#
-# Copyright (c) 2007 Andy Parkins
-#
-# An example hook script to mail out commit update information. This hook
-# sends emails listing new revisions to the repository introduced by the
-# change being reported. The rule is that (for branch updates) each commit
-# will appear on one email and one email only.
-#
-# This hook is stored in the contrib/hooks directory. Your distribution
-# will have put this somewhere standard. You should make this script
-# executable then link to it in the repository you would like to use it in.
-# For example, on debian the hook is stored in
-# /usr/share/git-core/contrib/hooks/post-receive-email:
-#
-# chmod a+x post-receive-email
-# cd /path/to/your/repository.git
-# ln -sf /usr/share/git-core/contrib/hooks/post-receive-email
hooks/post-receive
-#
-# This hook script assumes it is enabled on the central repository of a
-# project, with all users pushing only to it and not between each other. It
-# will still work if you don't operate in that style, but it would become
-# possible for the email to be from someone other than the person doing the
-# push.
-#
-# To help with debugging and use on pre-v1.5.1 git servers, this script will
-# also obey the interface of hooks/update, taking its arguments on the
-# command line. Unfortunately, hooks/update is called once for each ref.
-# To avoid firing one email per ref, this script just prints its output to
-# the screen when used in this mode. The output can then be redirected if
-# wanted.
-#
-# Config
-# ------
-# hooks.mailinglist
-# This is the list that all pushes will go to; leave it blank to not send
-# emails for every ref update.
-# hooks.announcelist
-# This is the list that all pushes of annotated tags will go to. Leave it
-# blank to default to the mailinglist field. The announce emails lists
-# the short log summary of the changes since the last annotated tag.
-# hooks.envelopesender
-# If set then the -f option is passed to sendmail to allow the envelope
-# sender address to be set
-# hooks.emailprefix
-# All emails have their subjects prefixed with this prefix, or "[SCM]"
-# if emailprefix is unset, to aid filtering
-# hooks.showrev
-# The shell command used to format each revision in the email, with
-# "%s" replaced with the commit id. Defaults to "git rev-list -1
-# --pretty %s", displaying the commit id, author, date and log
-# message. To list full patches separated by a blank line, you
-# could set this to "git show -C %s; echo".
-# To list a gitweb/cgit URL *and* a full patch for each change set, use this:
-# "t=%s; printf 'http://.../?id=%%s' \$t; echo;echo; git show -C \$t; echo"
-# Be careful if "..." contains things that will be expanded by shell "eval"
-# or printf.
-# hooks.emailmaxlines
-# The maximum number of lines that should be included in the generated
-# email body. If not specified, there is no limit.
-# Lines beyond the limit are suppressed and counted, and a final
-# line is added indicating the number of suppressed lines.
-# hooks.diffopts
-# Alternate options for the git diff-tree invocation that shows changes.
-# Default is "--stat --summary --find-copies-harder". Add -p to those
-# options to include a unified diff of changes in addition to the usual
-# summary output.
-#
-# Notes
-# -----
-# All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
-# "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
-# give information for debugging.
-#
+#!/usr/bin/env php
+<?php
+namespace Karma;
-# ---------------------------- Functions
+// STATUS: not worked
+// TODO: add license
+// TODO: mails per commit
+// TODO: refactor with lib/Git
+// TODO: documentation
+// TODO: refactor for PHP 5.4
+// TODO: reformat mails
+// TODO: check mail length
-#
-# Function to prepare for email generation. This decides what type
-# of update this is and whether an email should even be generated.
-#
-prep_for_email()
-{
- # --- Arguments
- oldrev=$(git rev-parse $1)
- newrev=$(git rev-parse $2)
- refname="$3"
- maxlines=$4
- # --- Interpret
- # 0000->1234 (create)
- # 1234->2345 (update)
- # 2345->0000 (delete)
- if expr "$oldrev" : '0*$' >/dev/null
- then
- change_type="create"
- else
- if expr "$newrev" : '0*$' >/dev/null
- then
- change_type="delete"
- else
- change_type="update"
- fi
- fi
+error_reporting(E_ALL | E_STRICT);
+date_default_timezone_set('UTC');
+putenv("PATH=/opt/bin:/usr/local/bin:/usr/bin:/bin");
+putenv("LC_ALL=en_US.UTF-8");
- # --- Get the revision types
- newrev_type=$(git cat-file -t $newrev 2> /dev/null)
- oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
- case "$change_type" in
- create|update)
- rev="$newrev"
- rev_type="$newrev_type"
- ;;
- delete)
- rev="$oldrev"
- rev_type="$oldrev_type"
- ;;
- esac
+const REPOSITORY_PATH = '/git/repositories';
- # The revision type tells us what type the commit is, combined with
- # the location of the ref we can decide between
- # - working branch
- # - tracking branch
- # - unannoted tag
- # - annotated tag
- case "$refname","$rev_type" in
- refs/tags/*,commit)
- # un-annotated tag
- refname_type="tag"
- short_refname=${refname##refs/tags/}
- ;;
- refs/tags/*,tag)
- # annotated tag
- refname_type="annotated tag"
- short_refname=${refname##refs/tags/}
- # change recipients
- if [ -n "$announcerecipients" ]; then
- recipients="$announcerecipients"
- fi
- ;;
- refs/heads/*,commit)
- # branch
- refname_type="branch"
- short_refname=${refname##refs/heads/}
- ;;
- refs/remotes/*,commit)
- # tracking branch
- refname_type="tracking branch"
- short_refname=${refname##refs/remotes/}
- echo >&2 "*** Push-update of tracking branch, $refname"
- echo >&2 "*** - no email generated."
- return 1
- ;;
- *)
- # Anything else (is there anything else?)
- echo >&2 "*** Unknown type of update to $refname
($rev_type)"
- echo >&2 "*** - no email generated"
- return 1
- ;;
- esac
+set_include_path('/git/checkout/karma/lib' .
+ PATH_SEPARATOR .
+ get_include_path());
- # Check if we've got anyone to send to
- if [ -z "$recipients" ]; then
- case "$refname_type" in
- "annotated tag")
- config_name="hooks.announcelist"
- ;;
- *)
- config_name="hooks.mailinglist"
- ;;
- esac
- return 1
- fi
+include 'Git.php';
+include 'Git/ReceiveHook.php';
+include 'Git/PostReceiveHook.php';
- return 0
-}
-
-#
-# Top level email generation function. This calls the appropriate
-# body-generation routine after outputting the common header.
-#
-# Note this function doesn't actually generate any email output, that is
-# taken care of by the functions it calls:
-# - generate_email_header
-# - generate_create_XXXX_email
-# - generate_update_XXXX_email
-# - generate_delete_XXXX_email
-# - generate_email_footer
-#
-# Note also that this function cannot 'exit' from the script; when this
-# function is running (in hook script mode), the send_mail() function
-# is already executing in another process, connected via a pipe, and
-# if this function exits without, whatever has been generated to that
-# point will be sent as an email... even if nothing has been generated.
-#
-generate_email()
-{
- # Email parameters
- # The email subject will contain the best description of the ref
- # that we can build from the parameters
- describe=$(git rev-parse --short $rev)
-
- generate_email_header
-
- # Call the correct body generation function
- fn_name=general
- case "$refname_type" in
- "tracking branch"|branch)
- fn_name=branch
- ;;
- "annotated tag")
- fn_name=atag
- ;;
- esac
-
- if [ -z "$maxlines" ]; then
- generate_${change_type}_${fn_name}_email
- else
- generate_${change_type}_${fn_name}_email | limit_lines $maxlines
- fi
-
- generate_email_footer
-}
-
-generate_email_header()
-{
- # --- Email (all stdout will be the email)
- # Generate header
- cat <<-EOF
- To: $recipients
- Subject: ${emailprefix}$projectdesc $refname_type $short_refname
${change_type}d. $describe
- X-Git-Refname: $refname
- X-Git-Reftype: $refname_type
- X-Git-Oldrev: $oldrev
- X-Git-Newrev: $newrev
-
- The $refname_type, $short_refname on $projectdesc has been
${change_type}d
- EOF
-}
-
-generate_email_footer()
-{
- SPACE=" "
- cat <<-EOF
-Thank you for your contribution.
- EOF
-}
-
-# --------------- Branches
-
-#
-# Called for the creation of a branch
-#
-generate_create_branch_email()
-{
- # This is a new branch and so oldrev is not valid
- echo " at $newrev ($newrev_type)"
- echo ""
-
- echo $LOGBEGIN
- show_new_revisions
- echo $LOGEND
-}
-
-#
-# Called for the change of a pre-existing branch
-#
-generate_update_branch_email()
-{
- # Consider this:
- # 1 --- 2 --- O --- X --- 3 --- 4 --- N
- #
- # O is $oldrev for $refname
- # N is $newrev for $refname
- # X is a revision pointed to by some other ref, for which we may
- # assume that an email has already been generated.
- # In this case we want to issue an email containing only revisions
- # 3, 4, and N. Given (almost) by
- #
- # git rev-list N ^O --not --all
- #
- # The reason for the "almost", is that the "--not --all" will take
- # precedence over the "N", and effectively will translate to
- #
- # git rev-list N ^O ^X ^N
- #
- # So, we need to build up the list more carefully. git rev-parse
- # will generate a list of revs that may be fed into git rev-list.
- # We can get it to make the "--not --all" part and then filter out
- # the "^N" with:
- #
- # git rev-parse --not --all | grep -v N
- #
- # Then, using the --stdin switch to git rev-list we have effectively
- # manufactured
- #
- # git rev-list N ^O ^X
- #
- # This leaves a problem when someone else updates the repository
- # while this script is running. Their new value of the ref we're
- # working on would be included in the "--not --all" output; and as
- # our $newrev would be an ancestor of that commit, it would exclude
- # all of our commits. What we really want is to exclude the current
- # value of $refname from the --not list, rather than N itself. So:
- #
- # git rev-parse --not --all | grep -v $(git rev-parse $refname)
- #
- # Get's us to something pretty safe (apart from the small time
- # between refname being read, and git rev-parse running - for that,
- # I give up)
- #
- #
- # Next problem, consider this:
- # * --- B --- * --- O ($oldrev)
- # \
- # * --- X --- * --- N ($newrev)
- #
- # That is to say, there is no guarantee that oldrev is a strict
- # subset of newrev (it would have required a --force, but that's
- # allowed). So, we can't simply say rev-list $oldrev..$newrev.
- # Instead we find the common base of the two revs and list from
- # there.
- #
- # As above, we need to take into account the presence of X; if
- # another branch is already in the repository and points at some of
- # the revisions that we are about to output - we don't want them.
- # The solution is as before: git rev-parse output filtered.
- #
- # Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
- #
- # Tags pushed into the repository generate nice shortlog emails that
- # summarise the commits between them and the previous tag. However,
- # those emails don't include the full commit messages that we output
- # for a branch update. Therefore we still want to output revisions
- # that have been output on a tag email.
- #
- # Luckily, git rev-parse includes just the tool. Instead of using
- # "--all" we use "--branches"; this has the added benefit that
- # "remotes/" will be ignored as well.
-
- # List all of the revisions that were removed by this update, in a
- # fast-forward update, this list will be empty, because rev-list O
- # ^N is empty. For a non-fast-forward, O ^N is the list of removed
- # revisions
- fast_forward=""
- rev=""
- for rev in $(git rev-list $newrev..$oldrev)
- do
- revtype=$(git cat-file -t "$rev")
- echo " discards $rev ($revtype)"
- done
- if [ -z "$rev" ]; then
- fast_forward=1
- fi
-
- # List all the revisions from baserev to newrev in a kind of
- # "table-of-contents"; note this list can include revisions that
- # have already had notification emails and is present to show the
- # full detail of the change from rolling back the old revision to
- # the base revision and then forward to the new revision
- for rev in $(git rev-list $oldrev..$newrev)
- do
- revtype=$(git cat-file -t "$rev")
- echo " via $rev ($revtype)"
- done
-
- if [ "$fast_forward" ]; then
- echo " from $oldrev ($oldrev_type)"
- else
- # 1. Existing revisions were removed. In this case newrev
- # is a subset of oldrev - this is the reverse of a
- # fast-forward, a rewind
- # 2. New revisions were added on top of an old revision,
- # this is a rewind and addition.
-
- # (1) certainly happened, (2) possibly. When (2) hasn't
- # happened, we set a flag to indicate that no log printout
- # is required.
-
- echo ""
-
- # Find the common ancestor of the old and new revisions and
- # compare it with newrev
- baserev=$(git merge-base $oldrev $newrev)
- rewind_only=""
- if [ "$baserev" = "$newrev" ]; then
- echo "This update discarded existing revisions and left
the branch pointing at"
- echo "a previous point in the repository history."
- echo ""
- echo " * -- * -- N ($newrev)"
- echo " \\"
- echo " O -- O -- O ($oldrev)"
- echo ""
- echo "The removed revisions are not necessarilly gone -
if another reference"
- echo "still refers to them they will stay in the
repository."
- rewind_only=1
- else
- echo "This update added new revisions after undoing
existing revisions. That is"
- echo "to say, the old revision is not a strict subset
of the new revision. This"
- echo "situation occurs when you --force push a change
and generate a repository"
- echo "containing something like this:"
- echo ""
- echo " * -- * -- B -- O -- O -- O ($oldrev)"
- echo " \\"
- echo " N -- N -- N ($newrev)"
- echo ""
- echo "When this happens we assume that you've already
had alert emails for all"
- echo "of the O revisions, and so we here report only
the revisions in the N"
- echo "branch from the common base, B."
- fi
- fi
-
- echo ""
- if [ -z "$rewind_only" ]; then
-# echo "Those revisions listed above that are new to this
repository have"
-# echo "not appeared on any other notification email; so we list
those"
-# echo "revisions in full, below."
-
- echo "http://git.php.net/?p=$project;a=log;h=$newrev;hp=$oldrev";
- echo ""
- echo "Summary of changes:"
- git diff-tree $diffopts $oldrev..$newrev
-
- echo ""
- echo $LOGBEGIN
- show_new_revisions
-
- # XXX: Need a way of detecting whether git rev-list actually
- # outputted anything, so that we can issue a "no new
- # revisions added by this update" message
-
-# echo $LOGEND
- else
- echo "No new revisions were added by this update."
- fi
-
- # The diffstat is shown from the old revision to the new revision.
- # This is to show the truth of what happened in this change.
- # There's no point showing the stat from the base to the new
- # revision because the base is effectively a random revision at this
- # point - the user will be interested in what this revision changed
- # - including the undoing of previous revisions in the case of
- # non-fast-forward updates.
-}
-
-#
-# Called for the deletion of a branch
-#
-generate_delete_branch_email()
-{
- echo " was $oldrev"
- echo ""
- echo $LOGEND
- git show -s --pretty=oneline $oldrev
- echo $LOGEND
-}
-
-# --------------- Annotated tags
-
-#
-# Called for the creation of an annotated tag
-#
-generate_create_atag_email()
-{
- echo " at $newrev ($newrev_type)"
-
- generate_atag_email
-}
-
-#
-# Called for the update of an annotated tag (this is probably a rare event
-# and may not even be allowed)
-#
-generate_update_atag_email()
-{
- echo " to $newrev ($newrev_type)"
- echo " from $oldrev (which is now obsolete)"
-
- generate_atag_email
-}
-
-#
-# Called when an annotated tag is created or changed
-#
-generate_atag_email()
-{
- # Use git for-each-ref to pull out the individual fields from the
- # tag
- eval $(git for-each-ref --shell --format='
- tagobject=%(*objectname)
- tagtype=%(*objecttype)
- tagger=%(taggername)
- tagged=%(taggerdate)' $refname
- )
- echo " tagging $tagobject ($tagtype)"
- case "$tagtype" in
- commit)
+$recipients = exec('git config hooks.mailinglist');
+$emailprefix = exec('git config hooks.emailprefix') ?: '[git]';
- # If the tagged object is a commit, then we assume this is a
- # release, and so we calculate which tag this tag is
- # replacing
- prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)
-
- if [ -n "$prevtag" ]; then
- echo " replaces $prevtag"
- fi
- ;;
- *)
- echo " length $(git cat-file -s $tagobject) bytes"
- ;;
- esac
- echo " tagged by $tagger"
- echo " on $tagged"
-
- echo ""
- echo $LOGBEGIN
-
- # Show the content of the tag message; this might contain a change
- # log or release notes so is worth displaying.
- git cat-file tag $newrev | sed -e '1,/^$/d'
-
- echo ""
- case "$tagtype" in
- commit)
- # Only commit tags make sense to have rev-list operations
- # performed on them
- if [ -n "$prevtag" ]; then
- # Show changes since the previous release
- git rev-list --pretty=short "$prevtag..$newrev" | git
shortlog
- else
- # No previous tag, show all the changes since time
- # began
- git rev-list --pretty=short $newrev | git shortlog
- fi
- ;;
- *)
- # XXX: Is there anything useful we can do for non-commit
- # objects?
- ;;
- esac
-
- echo $LOGEND
-}
-
-#
-# Called for the deletion of an annotated tag
-#
-generate_delete_atag_email()
-{
- echo " was $oldrev"
- echo ""
- echo $LOGEND
- git show -s --pretty=oneline $oldrev
- echo $LOGEND
-}
-
-# --------------- General references
-
-#
-# Called when any other type of reference is created (most likely a
-# non-annotated tag)
-#
-generate_create_general_email()
-{
- echo " at $newrev ($newrev_type)"
-
- generate_general_email
-}
-
-#
-# Called when any other type of reference is updated (most likely a
-# non-annotated tag)
-#
-generate_update_general_email()
-{
- echo " to $newrev ($newrev_type)"
- echo " from $oldrev"
-
- generate_general_email
-}
-
-#
-# Called for creation or update of any other type of reference
-#
-generate_general_email()
-{
- # Unannotated tags are more about marking a point than releasing a
- # version; therefore we don't do the shortlog summary that we do for
- # annotated tags above - we simply show that the point has been
- # marked, and print the log message for the marked point for
- # reference purposes
- #
- # Note this section also catches any other reference type (although
- # there aren't any) and deals with them in the same way.
-
- echo ""
- if [ "$newrev_type" = "commit" ]; then
- echo $LOGBEGIN
- git show --no-color --root -s --pretty=medium $newrev
- echo $LOGEND
- else
- # What can we do here? The tag marks an object that is not
- # a commit, so there is no log for us to display. It's
- # probably not wise to output git cat-file as it could be a
- # binary blob. We'll just say how big it is
- echo "$newrev is a $newrev_type, and is $(git cat-file -s
$newrev) bytes long."
- fi
-}
-
-#
-# Called for the deletion of any other type of reference
-#
-generate_delete_general_email()
-{
- echo " was $oldrev"
- echo ""
- echo $LOGEND
- git show -s --pretty=oneline $oldrev
- echo $LOGEND
-}
-
-
-# --------------- Miscellaneous utilities
-
-#
-# Show new revisions as the user would like to see them in the email.
-#
-show_new_revisions()
-{
- # This shows all log entries that are not already covered by
- # another ref - i.e. commits that are now accessible from this
- # ref that were previously not accessible
- # (see generate_update_branch_email for the explanation of this
- # command)
-
- # Revision range passed to rev-list differs for new vs. updated
- # branches.
- if [ "$change_type" = create ]
- then
- # Show all revisions exclusive to this (new) branch.
- revspec=$newrev
- else
- # Branch update; show revisions not part of $oldrev.
- revspec=$oldrev..$newrev
- fi
-
- other_branches=$(git for-each-ref --format='%(refname)' refs/heads/ |
- grep -F -v $refname)
- git rev-parse --not $other_branches |
- if [ -z "$custom_showrev" ]
- then
- git rev-list --pretty --stdin $revspec
- else
- git rev-list --stdin $revspec |
- while read onerev
- do
- eval $(printf "$custom_showrev" $onerev)
- done
- fi
-}
-
-
-limit_lines()
-{
- lines=0
- skipped=0
- while IFS="" read -r line; do
- lines=$((lines + 1))
- if [ $lines -gt $1 ]; then
- skipped=$((skipped + 1))
- else
- printf "%s\n" "$line"
- fi
- done
- if [ $skipped -ne 0 ]; then
- echo "... $skipped lines suppressed ..."
- fi
-}
-
-
-send_mail()
-{
- if [ -n "$envelopesender" ]; then
- /usr/sbin/sendmail -t -f "$envelopesender"
- else
- /usr/sbin/sendmail -t
- fi
+$user = null;
+if (getenv('REMOTE_USER')) {
+ $user = getenv('REMOTE_USER');
+} else if (getenv('SSH_CONNECTION') && getenv('GL_USER')) {
+ /* gitolite user */
+ $user = getenv('GL_USER');
}
-# ---------------------------- main()
-
-# --- Constants
-LOGBEGIN="-- Log ----------------------------------------"
-LOGEND=""
-
-# --- Config
-# Set GIT_DIR either from the working directory, or from the environment
-# variable.
-GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
-if [ -z "$GIT_DIR" ]; then
- echo >&2 "fatal: post-receive: GIT_DIR not set"
- exit 1
-fi
-
-#projectdesc=$(sed -ne '1p' "$GIT_DIR/description" 2>/dev/null)
-project=$(pwd | sed -e "s,/git/repositories/,,g" )
-projectdesc=$project
-# Check if the description is unchanged from it's default, and shorten it to
-# a more manageable length if it is
-if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
-then
- projectdesc="UNNAMED PROJECT"
-fi
-
-if [ -n "$GL_USER" ];
-then
- envelopesender="$gl_u...@php.net"
-elif [ -n "$REMOTE_USER" ];
-then
- envelopesender="$remote_u...@php.net"
-else
- envelopesender=$(git config hooks.envelopesender)
-fi
-
-recipients=$(git config hooks.mailinglist)
-announcerecipients=$(git config hooks.announcelist)
-emailprefix=$(git config hooks.emailprefix || echo '[git] ')
-custom_showrev=$(git config hooks.showrev)
-maxlines=$(git config hooks.emailmaxlines)
-diffopts=$(git config hooks.diffopts)
-: ${diffopts:="--stat --summary --find-copies-harder"}
-
-[ -n "$recipients" ] && echo "Sending notifications to $recipients."
-
-# --- Main loop
-# Allow dual mode: run from the command line just like the update hook, or
-# if no arguments are given then run as a hook script
-if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
- # Output to the terminal in command line mode - if someone wanted to
- # resend an email; they could redirect the output to sendmail
- # themselves
- prep_for_email $2 $3 $1 && PAGER= generate_email
-else
- while read oldrev newrev refname
- do
- prep_for_email $oldrev $newrev $refname || continue
- generate_email $maxlines | send_mail
- done
-fi
-
-echo ""
-
-[ -f 'hooks/post-receive.mirror' ] && hooks/post-receive.mirror
+$hook = new \Git\PostReceiveHook(getenv('GL_REPO_BASE_ABS') ?:
REPOSITORY_PATH, $user, $recipients, $emailprefix);
+$hook->process();
\ No newline at end of file
diff --git a/hooks/pre-receive b/hooks/pre-receive
index f9210e8..3370dc4 100755
--- a/hooks/pre-receive
+++ b/hooks/pre-receive
@@ -17,6 +17,7 @@ set_include_path('/git/checkout/karma/lib' .
get_include_path());
include 'Git/ReceiveHook.php';
+include 'Git/PreReceiveHook.php';
function deny($reason)
{
@@ -100,14 +101,14 @@ if (is_null($user)) {
fprintf(STDOUT, "Welcome $user.\n");
-$hook = new \Git\ReceiveHook(getenv('PHP_KARMA_FILE') ?: KARMA_FILE,
+$hook = new \Git\PreReceiveHook(getenv('PHP_KARMA_FILE') ?: KARMA_FILE,
getenv('GL_REPO_BASE_ABS') ?: REPOSITORY_PATH);
if ($hook->isKarmaIgnored()) {
accept("No karma check necessary. Thank you for your contribution.\n");
}
-$rep_name = $hook->getRepositoryName();
+$repo_name = $hook->getRepositoryName();
$pi = new \Git\PushInformation($hook);
$req_paths = ($pi->isForced()) ? [''] : $req_paths;
diff --git a/lib/Git/PostReceiveHook.php b/lib/Git/PostReceiveHook.php
new file mode 100644
index 0000000..96660a1
--- /dev/null
+++ b/lib/Git/PostReceiveHook.php
@@ -0,0 +1,158 @@
+<?php
+namespace Git;
+
+class PostReceiveHook extends ReceiveHook
+{
+
+ private $pushAuthor = '';
+ private $mailingList = '';
+ private $emailprefix = '';
+
+
+ private $refs = array();
+ private $revisions = array();
+
+ private $allBranches = array();
+
+
+ public function __construct($basePath, $pushAuthor, $mailingList,
$emailprefix)
+ {
+ parent::__construct($basePath);
+
+ $this->pushAuthor = $pushAuthor;
+ $this->mailingList = $mailingList;
+ $this->emailprefix = $emailprefix;
+
+ $this->allBranches = $this->getAllBranches();
+ }
+
+ private function getAllBranches()
+ {
+ return explode("\n", $this->execute('git for-each-ref
--format="%%(refname)" "refs/heads/*"'));
+ }
+
+
+ private function execute($cmd)
+ {
+ $args = func_get_args();
+ array_shift($args);
+ $output = shell_exec(vsprintf($cmd, $args));
+ return $output;
+ }
+
+ public function process()
+ {
+ $this->refs = $this->hookInput();
+
+ //send mails per ref push
+ foreach ($this->refs as $ref) {
+ if ($ref['reftype'] == self::REF_TAG) {
+ $this->sendTagMail($ref);
+ } else {
+ $this->sendBranchMail($ref);
+ }
+ }
+
+ // TODO: mail per commit
+ // send mail only about new commits
+ // But for new branches we must check if this branch was
+ // cloned from other branch in this push - it's especial case
+ // TODO: check old post-receive for other especial cases
+ }
+
+ private function sendBranchMail(array $branch)
+ {
+
+ if ($branch['changetype'] == self::TYPE_UPDATED) {
+ $title = "Branch " . $branch['refname'] . " was updated";
+ $message = $title . "\n\n";
+ } elseif ($branch['changetype'] == self::TYPE_CREATED) {
+ $title = "Branch " . $branch['refname'] . " was created";
+ $message = $title . "\n\n";
+ } else {
+ $title = "Branch " . $branch['refname'] . " was deleted";
+ $message = $title . "\n\n";
+ }
+
+
+
+ if ($branch['changetype'] != self::TYPE_DELETED) {
+
+ // TODO: cache revisions to $this->revisions
+ if ($branch['changetype'] == self::TYPE_UPDATED) {
+ // git rev-list old..new
+ $revisions = $this->getRevisions($branch['old'] . '..' .
$branch['new']);
+ } else {
+ // for new branch we write log about new commits only
+ $revisions = $this->getRevisions($branch['new']. ' --not ' .
implode(' ', $this->allBranches));
+ }
+
+ $message .= "--------LOG--------\n";
+ foreach ($revisions as $revision) {
+ $diff = $this->execute(
+ 'git diff-tree --stat --pretty=medium -c %s',
+ $revision
+ );
+
+ $message .= $diff."\n\n";
+ }
+ }
+
+ $this->mail($this->emailprefix . '[push] ' . $title , $message);
+ }
+
+ private function sendTagMail(array $tag)
+ {
+
+ if ($tag['changetype'] == self::TYPE_UPDATED) {
+ $title = "Tag " . $tag['refname'] . " was updated";
+ $message = $title . "\n\n";
+ } elseif ($tag['changetype'] == self::TYPE_CREATED) {
+ $title = "Tag " . $tag['refname'] . " was created";
+ $message = $title . "\n\n";
+ } else {
+ $title = "Tag " . $tag['refname'] . " was deleted";
+ $message = $title . "\n\n";
+ }
+
+ if ($tag['changetype'] != self::TYPE_CREATED) $isAnnotatedOldTag =
$this->isAnnotatedTag($tag['old']);
+ if ($tag['changetype'] != self::TYPE_DELETED) $isAnnotatedNewTag =
$this->isAnnotatedTag($tag['new']);
+
+ // TODO: write info about tag and target
+
+ $this->mail($this->emailprefix . '[push] ' . $title , $message);
+ }
+
+ private function isAnnotatedTag($rev)
+ {
+ return $this->execute('git for-each-ref --format="%%(objecttype)" %s',
$rev) == 'tag';
+ }
+
+
+ private function getRevisions($revRange)
+ {
+ $output = $this->execute(
+ 'git rev-list %s',
+ $revRange
+ );
+ $output = trim($output);
+ $revisions = $output ? explode("\n", trim($output)) : array();
+ return $revisions;
+ }
+
+
+ private function mail($subject, $message) {
+ $headers = array(
+ 'From: ' . $this->pushAuthor . '@php.net',
+ 'Reply-To: ' . $this->pushAuthor . '@php.net'
+ );
+
+ mail($this->mailingList, $subject, $message, implode("\r\n",
$headers));
+ }
+
+
+ private function isRevExistsInBranches($revision, array $branches) {
+ return !(bool) $this->execute('git rev-list --max-count=1 %s --not
%s', $revision, implode(' ', $branches));
+ }
+
+}
diff --git a/lib/Git/ReceiveHook.php b/lib/Git/PreReceiveHook.php
similarity index 54%
copy from lib/Git/ReceiveHook.php
copy to lib/Git/PreReceiveHook.php
index 7fa43d9..c1e8e03 100644
--- a/lib/Git/ReceiveHook.php
+++ b/lib/Git/PreReceiveHook.php
@@ -1,47 +1,28 @@
<?php
namespace Git;
-class ReceiveHook
+class PreReceiveHook extends ReceiveHook
{
const INPUT_PATTERN = '@^([0-9a-f]{40}) ([0-9a-f]{40}) (.+)$@i';
private $karmaFile;
- private $repositoryBasePath;
public function __construct($karma_file, $base_path)
{
+ parent::__construct($base_path);
$this->karmaFile = $karma_file;
- $this->repositoryBasePath = $base_path;
}
/**
- * Returns true if git option karma.ignored is set, otherwise false.
- *
- * @return boolean
- */
+ * Returns true if git option karma.ignored is set, otherwise false.
+ *
+ * @return boolean
+ */
public function isKarmaIgnored()
{
return 'true' === exec(sprintf('%s config karma.ignored',
\Git::GIT_EXECUTABLE));
}
- /**
- * Returns the repository name.
- *
- * A repository name is the path to the repository without the .git.
- * e.g. php-src.git -> php-src
- *
- * @return string
- */
- public function getRepositoryName()
- {
- $rel_path = str_replace($this->repositoryBasePath, '',
\Git::getRepositoryPath());
- if (preg_match('@/(.*\.git)$@', $rel_path, $matches)) {
- return $matches[1];
- }
-
- return '';
- }
-
public function mapInput(callable $fn) {
$result = [];
foreach($this->hookInput() as $input) {
@@ -52,58 +33,32 @@ class ReceiveHook
}
/**
- * Parses the input from git.
- *
- * Git pipes a list of oldrev, newrev and revname combinations
- * to the hook. We parse this input. For more information about
- * the input see githooks(5).
- *
- * Returns an array with 'old', 'new', 'refname' keys for each ref that
- * will be updated.
- * @return array
- */
- public function hookInput()
- {
- static $parsed_input = [];
- while (!feof(STDIN)) {
- $line = fgets(STDIN);
- if (preg_match(self::INPUT_PATTERN, $line, $matches)) {
- $parsed_input[] = [
- 'old' => $matches[1],
- 'new' => $matches[2],
- 'refname' => $matches[3]];
- }
- }
- return $parsed_input;
- }
-
- /**
- * Return the content of the karma file from the karma repository.
- *
- * We read the content of the karma file from the karma repository index.
- *
- * @return string
- */
+ * Return the content of the karma file from the karma repository.
+ *
+ * We read the content of the karma file from the karma repository index.
+ *
+ * @return string
+ */
public function getKarmaFile()
{
return file($this->karmaFile);
}
/**
- * Returns an array of files that were updated between revision $old and
$new.
- *
- * @param string $old The old revison number.
- * @parma string $new The new revison umber.
- *
- * @return array
- */
+ * Returns an array of files that were updated between revision $old and
$new.
+ *
+ * @param string $old The old revison number.
+ * @parma string $new The new revison umber.
+ *
+ * @return array
+ */
private function getReceivedPathsForRange($old, $new)
{
$repourl = \Git::getRepositoryPath();
$output = [];
/* there is the case where we push a new branch. check only new
commits.
- in case its a brand new repo, no heads will be available. */
+ in case its a brand new repo, no heads will be available. */
if ($old == \Git::NULLREV) {
exec(
sprintf("%s --git-dir=%s for-each-ref --format='%%(refname)'
'refs/heads/*'",
@@ -120,12 +75,12 @@ class ReceiveHook
sprintf('%s --git-dir=%s log --name-only --pretty=format:"" %s
%s',
\Git::GIT_EXECUTABLE, $repourl, $not,
escapeshellarg($new)), $output);
- } else {
+ } else {
exec(
sprintf('%s --git-dir=%s log --name-only --pretty=format:""
%s..%s',
\Git::GIT_EXECUTABLE, $repourl, escapeshellarg($old),
escapeshellarg($new)), $output);
- }
+ }
return $output;
}
@@ -137,7 +92,7 @@ class ReceiveHook
function ($input) {
return $this->getReceivedPathsForRange($input['old'],
$input['new']);
},
- $parsed_input);
+ $parsed_input);
/* remove empty lines, and flattern the array */
$flattend = array_reduce($paths, 'array_merge', []);
diff --git a/lib/Git/ReceiveHook.php b/lib/Git/ReceiveHook.php
index 7fa43d9..f332f71 100644
--- a/lib/Git/ReceiveHook.php
+++ b/lib/Git/ReceiveHook.php
@@ -1,27 +1,25 @@
<?php
namespace Git;
-class ReceiveHook
+abstract class ReceiveHook
{
const INPUT_PATTERN = '@^([0-9a-f]{40}) ([0-9a-f]{40}) (.+)$@i';
- private $karmaFile;
- private $repositoryBasePath;
+ const TYPE_UPDATED = 0;
+ const TYPE_CREATED = 1;
+ const TYPE_DELETED = 2;
- public function __construct($karma_file, $base_path)
- {
- $this->karmaFile = $karma_file;
- $this->repositoryBasePath = $base_path;
- }
+ const REF_BRANCH = 0;
+ const REF_TAG = 1;
- /**
- * Returns true if git option karma.ignored is set, otherwise false.
- *
- * @return boolean
- */
- public function isKarmaIgnored()
+ private $repositoryName = '';
+
+ public function __construct($basePath)
{
- return 'true' === exec(sprintf('%s config karma.ignored',
\Git::GIT_EXECUTABLE));
+ $rel_path = str_replace($basePath, '', \Git::getRepositoryPath());
+ if (preg_match('@/(.*\.git)$@', $rel_path, $matches)) {
+ $this->repositoryName = $matches[1];
+ }
}
/**
@@ -34,21 +32,7 @@ class ReceiveHook
*/
public function getRepositoryName()
{
- $rel_path = str_replace($this->repositoryBasePath, '',
\Git::getRepositoryPath());
- if (preg_match('@/(.*\.git)$@', $rel_path, $matches)) {
- return $matches[1];
- }
-
- return '';
- }
-
- public function mapInput(callable $fn) {
- $result = [];
- foreach($this->hookInput() as $input) {
- $result[] = $fn($input['old'], $input['new']);
- }
-
- return $result;
+ return $this->repositoryName;
}
/**
@@ -64,85 +48,46 @@ class ReceiveHook
*/
public function hookInput()
{
- static $parsed_input = [];
+ $parsed_input = array();
while (!feof(STDIN)) {
$line = fgets(STDIN);
if (preg_match(self::INPUT_PATTERN, $line, $matches)) {
- $parsed_input[] = [
+
+ $ref = array(
'old' => $matches[1],
'new' => $matches[2],
- 'refname' => $matches[3]];
+ 'refname' => $matches[3]
+ );
+
+ if (preg_match('~^refs/heads/.+$~', $ref['refname'])) {
+ // git push origin branchname
+ $ref['reftype'] = self::REF_BRANCH;
+ } elseif (preg_match('~^refs/tags/.+$~', $ref['refname'])) {
+ // git push origin tagname
+ $ref['reftype'] = self::REF_TAG;
+ } else {
+ // not support by this script
+ $ref['reftype'] = null;
+ }
+
+ if ($ref['old'] == \GIT::NULLREV) {
+ // git branch branchname && git push origin branchname
+ // git tag tagname rev && git push origin tagname
+ $ref['changetype'] = self::TYPE_CREATED;
+ } elseif ($ref['new'] == \GIT::NULLREV) {
+ // git branch -d branchname && git push origin :branchname
+ // git tag -d tagname && git push origin :tagname
+ $ref['changetype'] = self::TYPE_DELETED;
+ } else {
+ // git push origin branchname
+ // git tag -f tagname rev && git push origin tagname
+ $ref['changetype'] = self::TYPE_UPDATED;
+ }
+
+
+ $parsed_input[] = $ref;
}
}
return $parsed_input;
}
-
- /**
- * Return the content of the karma file from the karma repository.
- *
- * We read the content of the karma file from the karma repository index.
- *
- * @return string
- */
- public function getKarmaFile()
- {
- return file($this->karmaFile);
- }
-
- /**
- * Returns an array of files that were updated between revision $old and
$new.
- *
- * @param string $old The old revison number.
- * @parma string $new The new revison umber.
- *
- * @return array
- */
- private function getReceivedPathsForRange($old, $new)
- {
- $repourl = \Git::getRepositoryPath();
- $output = [];
-
- /* there is the case where we push a new branch. check only new
commits.
- in case its a brand new repo, no heads will be available. */
- if ($old == \Git::NULLREV) {
- exec(
- sprintf("%s --git-dir=%s for-each-ref --format='%%(refname)'
'refs/heads/*'",
- \Git::GIT_EXECUTABLE, $repourl), $output);
- /* do we have heads? otherwise it's a new repo! */
- $heads = implode(' ', $output);
- if (count($output) > 0) {
- $not = array_map(
- function($x) {
- return sprintf('--not %s', escapeshellarg($x));
- }, $heads);
- }
- exec(
- sprintf('%s --git-dir=%s log --name-only --pretty=format:"" %s
%s',
- \Git::GIT_EXECUTABLE, $repourl, $not,
- escapeshellarg($new)), $output);
- } else {
- exec(
- sprintf('%s --git-dir=%s log --name-only --pretty=format:""
%s..%s',
- \Git::GIT_EXECUTABLE, $repourl, escapeshellarg($old),
- escapeshellarg($new)), $output);
- }
- return $output;
- }
-
- public function getReceivedPaths()
- {
- $parsed_input = $this->hookInput();
-
- $paths = array_map(
- function ($input) {
- return $this->getReceivedPathsForRange($input['old'],
$input['new']);
- },
- $parsed_input);
-
- /* remove empty lines, and flattern the array */
- $flattend = array_reduce($paths, 'array_merge', []);
- $paths = array_filter($flattend);
-
- return array_unique($paths);
- }
}
commit 373c2053d9ac29ab7d2750b25e939a5b4a0dfc17
Author: David Soria Parra <d...@php.net>
Date: Fri Mar 2 03:06:30 2012 +0100
Require access to all the repository in case we do a forced push
A forced push can happen when you delete a tag or rewrite commits. We allow
this, but only if you have access to the root of the repository.
diff --git a/hooks/pre-receive b/hooks/pre-receive
index 46195a4..f9210e8 100755
--- a/hooks/pre-receive
+++ b/hooks/pre-receive
@@ -107,16 +107,18 @@ if ($hook->isKarmaIgnored()) {
accept("No karma check necessary. Thank you for your contribution.\n");
}
-$requested_paths = $hook->getReceivedPaths();
+$rep_name = $hook->getRepositoryName();
+$pi = new \Git\PushInformation($hook);
+$req_paths = ($pi->isForced()) ? [''] : $req_paths;
-if (empty($requested_paths)) {
+if (empty($req_paths)) {
deny("We cannot figure out what you comitted!");
}
-$prefix = sprintf('%s/', $hook->getRepositoryName());
+$prefix = sprintf('%s/', $repo_name);
$avail_lines = $hook->getKarmaFile();
-$requested_paths = array_map(function ($x) use ($prefix) { return $prefix .
$x;}, $requested_paths);
-$unavail_paths = get_unavail_paths($user, $requested_paths, $avail_lines);
+$req_paths = array_map(function ($x) use ($prefix) { return $prefix .
$x;}, $req_paths);
+$unavail_paths = get_unavail_paths($user, $req_paths, $avail_lines);
if (!empty($unavail_paths)) {
deny(sprintf(
diff --git a/lib/Git/PushInformation.php b/lib/Git/PushInformation.php
new file mode 100644
index 0000000..b0671a0
--- /dev/null
+++ b/lib/Git/PushInformation.php
@@ -0,0 +1,83 @@
+<?php
+namespace Git;
+
+class PushInformation
+{
+ const GIT_EXECUTABLE = 'git';
+
+ private $karmaFile;
+ private $repositoryBasePath;
+
+ private $hook = null;
+ private $repourl = null;
+
+ public function __construct(ReceiveHook $hook)
+ {
+ $this->repourl = \Git::getRepositoryPath();
+ }
+
+ /**
+ * Returns the common ancestor revision for two given revisions
+ *
+ * Returns false if no sha1 was returned. Throws an exception if calling
+ * git fails.
+ *
+ * @return boolean
+ */
+ protected function mergeBase($oldrev, $newrev)
+ {
+ $baserev = exec(sprintf('%s --git-dir=%s merge-base %s %s',
+ self::GIT_EXECUTABLE,
+ $this->repourl,
+ escapeshellarg($oldrev),
+ escapeshellarg($newrev)), $retval);
+
+ $baserev = trim($baserev);
+
+ if (0 !== $retval) {
+ throw new \Exception('Failed to call git');
+ }
+
+ if (40 != strlen($baserev)) {
+ return false;
+ }
+
+ return $baserev;
+ }
+
+ /**
+ * Returns true if merging $newrev would be fast forward
+ *
+ * @return boolean
+ */
+ public function isFastForward()
+ {
+ $result = $this->hook->mapInput(
+ function ($oldrev, $newrev) {
+ if ($oldrev == \Git::NULLREV) {
+ return true;
+ }
+ return $oldrev == $this->mergeBase($oldrev, $newrev);
+ });
+
+ return array_reduce($result, function($a, $b) { return $a && $b; },
true);
+ }
+
+ /**
+ * Returns true if updating the refs would fail if push is not forced.
+ *
+ * @return boolean
+ */
+ public function isForced()
+ {
+ $result = $this->hook->mapInput(
+ function($oldrev, $newrev) {
+ if ($oldrev == \Git::NULLREV) {
+ return false;
+ }
+ return $newrev == $this->mergeBase($oldrev, $newrev);
+ });
+
+ return array_reduce($result, function($a, $b) { return $a || $b; },
false);
+ }
+}
diff --git a/lib/Git/ReceiveHook.php b/lib/Git/ReceiveHook.php
index e17d055..7fa43d9 100644
--- a/lib/Git/ReceiveHook.php
+++ b/lib/Git/ReceiveHook.php
@@ -42,6 +42,15 @@ class ReceiveHook
return '';
}
+ public function mapInput(callable $fn) {
+ $result = [];
+ foreach($this->hookInput() as $input) {
+ $result[] = $fn($input['old'], $input['new']);
+ }
+
+ return $result;
+ }
+
/**
* Parses the input from git.
*
commit f3d11575dc77ab1cc7eda290a4366122b923b1c1
Author: David Soria Parra <d...@php.net>
Date: Fri Feb 10 20:37:36 2012 +0100
Separate class for git related code without other dependencies
Git related code that does not have dependencies to the gitolite
environment is now in the Git class.
diff --git a/lib/Git.php b/lib/Git.php
new file mode 100644
index 0000000..ee3e95c
--- /dev/null
+++ b/lib/Git.php
@@ -0,0 +1,25 @@
+<?php
+
+class Git
+{
+ const GIT_EXECUTABLE = 'git';
+ const NULLREV = '0000000000000000000000000000000000000000';
+
+ /**
+ * Returns the path to the current repository.
+ *
+ * Tries to determine the path of the current repository in which
+ * the hook was invoked.
+ *
+ * @return string
+ */
+ public static function getRepositoryPath()
+ {
+ $path = exec(sprintf('%s rev-parse --git-dir', self::GIT_EXECUTABLE));
+ if (!is_dir($path)) {
+ return false;
+ }
+
+ return realpath($path);
+ }
+}
diff --git a/lib/Git/ReceiveHook.php b/lib/Git/ReceiveHook.php
index 0115264..e17d055 100644
--- a/lib/Git/ReceiveHook.php
+++ b/lib/Git/ReceiveHook.php
@@ -3,7 +3,6 @@ namespace Git;
class ReceiveHook
{
- const GIT_EXECUTABLE = 'git';
const INPUT_PATTERN = '@^([0-9a-f]{40}) ([0-9a-f]{40}) (.+)$@i';
private $karmaFile;
@@ -22,7 +21,7 @@ class ReceiveHook
*/
public function isKarmaIgnored()
{
- return 'true' === exec(sprintf('%s config karma.ignored',
self::GIT_EXECUTABLE));
+ return 'true' === exec(sprintf('%s config karma.ignored',
\Git::GIT_EXECUTABLE));
}
/**
@@ -35,7 +34,7 @@ class ReceiveHook
*/
public function getRepositoryName()
{
- $rel_path = str_replace($this->repositoryBasePath, '',
$this->getRepositoryPath());
+ $rel_path = str_replace($this->repositoryBasePath, '',
\Git::getRepositoryPath());
if (preg_match('@/(.*\.git)$@', $rel_path, $matches)) {
return $matches[1];
}
@@ -44,24 +43,6 @@ class ReceiveHook
}
/**
- * Returns the path to the current repository.
- *
- * Tries to determine the path of the current repository in which
- * the hook was invoked.
- *
- * @return string
- */
- public function getRepositoryPath()
- {
- $path = exec(sprintf('%s rev-parse --git-dir', self::GIT_EXECUTABLE));
- if (!is_dir($path)) {
- return false;
- }
-
- return realpath($path);
- }
-
- /**
* Parses the input from git.
*
* Git pipes a list of oldrev, newrev and revname combinations
@@ -109,15 +90,15 @@ class ReceiveHook
*/
private function getReceivedPathsForRange($old, $new)
{
- $repourl = $this->getRepositoryPath();
+ $repourl = \Git::getRepositoryPath();
$output = [];
/* there is the case where we push a new branch. check only new
commits.
in case its a brand new repo, no heads will be available. */
- if ($old == '0000000000000000000000000000000000000000') {
+ if ($old == \Git::NULLREV) {
exec(
sprintf("%s --git-dir=%s for-each-ref --format='%%(refname)'
'refs/heads/*'",
- self::GIT_EXECUTABLE, $repourl), $output);
+ \Git::GIT_EXECUTABLE, $repourl), $output);
/* do we have heads? otherwise it's a new repo! */
$heads = implode(' ', $output);
if (count($output) > 0) {
@@ -128,12 +109,12 @@ class ReceiveHook
}
exec(
sprintf('%s --git-dir=%s log --name-only --pretty=format:"" %s
%s',
- self::GIT_EXECUTABLE, $repourl, $not,
+ \Git::GIT_EXECUTABLE, $repourl, $not,
escapeshellarg($new)), $output);
} else {
exec(
sprintf('%s --git-dir=%s log --name-only --pretty=format:""
%s..%s',
- self::GIT_EXECUTABLE, $repourl, escapeshellarg($old),
+ \Git::GIT_EXECUTABLE, $repourl, escapeshellarg($old),
escapeshellarg($new)), $output);
}
return $output;
commit 51ca66d43a28b1c50cfd4e994712bc577e440e52
Author: David Soria Parra <d...@php.net>
Date: Fri Feb 10 17:00:52 2012 +0100
Use getenv instead of $_ENV
$_ENV should not be used in production and is not in the set in recent
php.ini.
Therefore we have to use getenv instead of $_ENV.
diff --git a/hooks/pre-receive b/hooks/pre-receive
index a687a77..46195a4 100755
--- a/hooks/pre-receive
+++ b/hooks/pre-receive
@@ -3,7 +3,7 @@
/*
* The PHP.net KARMA hook. For git repositories.
*
- * (c) 2011 David Soria Parra <dsp at php dot net>
+ * (c) 2012 David Soria Parra <dsp at php dot net>
*
* Licensed under the terms of the MIT license.
*/
@@ -87,11 +87,11 @@ putenv("PATH=/opt/bin:/usr/local/bin:/usr/bin:/bin");
putenv("LC_ALL=en_US.UTF-8");
$user = null;
-if (isset($_ENV['REMOTE_USER'])) {
- $user = $_ENV['REMOTE_USER'];
-} else if (isset($_ENV['SSH_CONNECTION']) && isset($_ENV['GL_USER'])) {
+if (getenv('REMOTE_USER')) {
+ $user = getenv('REMOTE_USER');
+} else if (getenv('SSH_CONNECTION') && getenv('GL_USER')) {
/* gitolite user */
- $user = $_ENV['GL_USER'];
+ $user = getenv('GL_USER');
}
if (is_null($user)) {
commit c358027fd70d57b60f12b620dc78f6fe7c384aec
Author: David Soria Parra <d...@php.net>
Date: Fri Feb 3 11:39:20 2012 +0100
Proper --not handling
diff --git a/lib/Git/ReceiveHook.php b/lib/Git/ReceiveHook.php
index 6776a2a..0115264 100644
--- a/lib/Git/ReceiveHook.php
+++ b/lib/Git/ReceiveHook.php
@@ -120,7 +120,12 @@ class ReceiveHook
self::GIT_EXECUTABLE, $repourl), $output);
/* do we have heads? otherwise it's a new repo! */
$heads = implode(' ', $output);
- $not = count($output) > 0 ? sprintf('--not %s',
escapeshellarg($heads)) : '';
+ if (count($output) > 0) {
+ $not = array_map(
+ function($x) {
+ return sprintf('--not %s', escapeshellarg($x));
+ }, $heads);
+ }
exec(
sprintf('%s --git-dir=%s log --name-only --pretty=format:"" %s
%s',
self::GIT_EXECUTABLE, $repourl, $not,
Thank you for your contribution.
--
PHP CVS Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php
