path: root/bin/git-gpush

#!/usr/bin/env perl
# Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
# Contact: http://www.qt-project.org/legal
#
# You may use this file under the terms of the 3-clause BSD license.
# See the file LICENSE from this package for details.
#

use strict;
use warnings;

use Carp;
$SIG{__WARN__} = \&Carp::cluck;

use File::Basename;

# Cannot use Pod::Usage for this file, since git on Windows will invoke its own perl version, which
# may not (msysgit for example) support this module, even if it's considered a Core module.
sub usage
{
    print << "EOM";
Usage:
    git gpush [opts] [remote] [[sha1/ref-from]:[ref-to]] [+<reviewer>] [=<CC user>] [-- <push opts>]

    Pushes changes to Gerrit and adds reviewers and CC to the patch
    sets

Description:
    This script is used to push patch sets to Gerrit, and at the same
    time add reviewers and CCs to the patch sets pushed.

    You can use email addresses, Gerrit usernames or aliases for the
    name of the reviewers/CCs.

    If no sha1 or ref-from is specified, 'HEAD' is used.

    If no ref-to is specified, the remote tracking branch for 'ref-from'
    is used as
        'refs/for/<remote tracking branch>'.

    If no remote is specified or configured, 'gerrit' is used. You may
    configure a remote like this:
        git config gpush.remote <remote name>

    If all the options above have been populated, the remainder
    options are passed on directly to the normal 'git push' command.
    If you want to avoid specifying all options first, any options
    specified after a '--' are also passed on directly to the
    underlying 'git push' command.

Options:
    -d, --draft
        Mark the pushed changes as drafts. This switch is usually
        unnecessary, as gpush will recognize WIP changes by subject.

    -p, --publish
        Do not mark the pushed changes as drafts even if they have
        WIP markers.

    --aliases
        Report all registered aliases and quit.

    -n, --dry-run
        Do everything except actually pushing any commits.

    -v, --verbose
        Show the resolved aliases, SHA1s of commits, and other information.

    -q, --quiet
        Suppress the usual output about what is pushed where.

    --debug
        Print debug information.

Configuring Aliases:
    Aliases are read from the
        .git-gpush-aliases
    located next to the script, then from the git config which may
    have aliases set either locally in the current repository,
    globally (in your ~/.gitconfig), or system-wide.

    You can add aliases to your global git config like this:
        git config --global gpush.alias.<alias key> <alias value>
    and if you only want it to be local to the current repository,
    just drop the --global option.
    Note that git config keys are constrained regarding allowed
    characters, so it is impossible to map some IRC nicks via git
    configuration.

    An alias may contain multiple comma-separated email addresses;
    for example, to set a single alias for an entire team.

    Inside .git-gpush-aliases, each alias may also be a comma-separated
    list, in case a user uses multiple handles.

Copyright:
    Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
    Contact: http://www.qt-project.org/legal

License:
    You may use this file under the terms of the 3-clause BSD license.
EOM
}

my $debug = 0;
my $verbose = 0;
my $quiet = 0;
my $dry_run = 0;

my $remote = "gerrit";
my $remote_override = 0;
my $ref_from = "HEAD";
my $ref_to = "";
my $ref_override = 0;
my $draft = 0;

my %aliases;

my @reviewers;
my @CCs;

my @arguments;

sub format_cmd(@)
{
    return join(' ', map { /\s/ ? '"' . $_ . '"' : $_ } @_);
}

sub read_git_line(@)
{
    print "+ " . format_cmd('git', @_) . "\n" if ($debug);
    open PROC, '-|', 'git', @_
        or die("Failed to run \"git\": $!\n");
    my $line = <PROC>;
    if (defined($line)) {
        chomp $line ;
        print "- $line\n" if ($debug);
    }
    close PROC;
    return $line;
}

sub parse_arguments(@)
{
    while (scalar @_) {
        my $arg = shift @_;

        if ($arg eq "-v" || $arg eq "--verbose") {
            $verbose = 1;
        } elsif ($arg eq "-q" || $arg eq "--quiet") {
            $quiet = 1;
        } elsif ($arg eq "--debug") {
            $debug = 1;
            $verbose = 1;
        } elsif ($arg eq "-n" || $arg eq "--dry-run") {
            $dry_run = 1;
        } elsif ($arg eq "-d" || $arg eq "--draft") {
            $draft = 1;
        } elsif ($arg eq "-p" || $arg eq "--publish") {
            $draft = -1;
        } elsif ($arg eq "--aliases") {
            foreach my $key (sort(keys %aliases)) {
                print "$key = $aliases{$key}\n";
            }
            exit 0;
        } elsif ($arg eq "-?" || $arg eq "--?" || $arg eq "-h" || $arg eq "--help") {
            usage();
            exit 0;
        } elsif ($arg eq "--") {
            push @arguments, @_;
            return;
        } elsif ($arg =~ /^\+(.+)/) {
            push @reviewers, split(/,/, lookup_alias($1));
        } elsif ($arg =~ /^\=(.+)/) {
            push @CCs, split(/,/, lookup_alias($1));
        } elsif ($arg =~ /^\-(.+)/) {
            push @arguments, $arg;
        } elsif (!$remote_override || !$ref_override) {
            if ($arg =~ /(.*):(.*)/) {
                $ref_from = $1 if (defined $1 && $1 ne "");
                $ref_to = $2 if (defined $2 && $2 ne "");
                $ref_override = 1;
            } else {
                $remote = $arg;
                $remote_override = 1;
            }
        } else {
            push @arguments, $arg;
        }
    }

    die("--quiet and --verbose/--debug are mutually exclusive.\n")
        if ($quiet && $verbose);

    if ($ref_to =~ s,^refs/for/,,) {
        die "Pushing to refs/for/ is inconsistent with the --draft option.\n" if ($draft > 0);
        print STDERR "Notice: it is unnecessary to specify refs/for/ in the target ref.\n"
            if (!$quiet);
    } elsif ($ref_to =~ s,^refs/drafts/,,) {
        die "Pushing to refs/drafts/ is inconsistent with the --publish option.\n" if ($draft < 0);
        if ($draft) {
            print STDERR "Notice: it is unnecessary to specify refs/drafts/ in the target ref.\n"
                if (!$quiet);
        } else {
            print STDERR "Notice: prefer the --draft option over specifying refs/drafts/ in the target ref.\n"
                if (!$quiet);
            $draft = 1;
        }
    }
}

sub fileContents($)
{
    my ($filename) = @_;

    my @contents = "";
    my $fh;
    if (-e $filename && open($fh, "< $filename")) {
        @contents = <$fh>;
        close $fh;
    }
    return @contents;
}

sub load_aliases()
{
    my $script_path = dirname($0);

    # Read aliases from .git-gpush-aliases file
    foreach my $line (fileContents("$script_path/.git-gpush-aliases")) {
        chomp $line;
        $line =~ s,(#|//).*$,,;             # Remove any comments
        if ($line =~ /([^ ]+)\s*=\s*(\S+)/) {  # Capture the alias
            for my $alias (split(/,/, $1)) {
                $aliases{$alias} = $2;
            }
        }
    }

    # Read aliases and configurations from git config
    my @gitconfigs = `git config --get-regexp gpush.*`;
    return if ($?); # just return if no git configs for gpush

    foreach (@gitconfigs) {
        if (/^gpush\.remote (\w+)/) {
            $remote = $2;
        } elsif (/^gpush\.ref-from (.+)/) {
            die("Configuring ref-from is not supported any more.\n");
        } elsif (/^gpush\.ref-to (.+)/) {
            die("Configuring ref-to is not supported any more.\n");
        } elsif (/^gpush\.alias\.([^ ]*) (.+)/) {
            $aliases{$1} = $2;
        } # else ignore
    }
}

sub lookup_alias($)
{
    my ($user) = @_;

    my $alias = $aliases{$user};
    if (defined $alias && $alias ne "") {
        print "Resolved $user to $alias.\n" if ($verbose);
        return $alias;
    }

    return $user;
}

sub add_reviewers()
{
    if (@reviewers || @CCs) {
        my @dudes;
        push @dudes, "--receive-pack=git receive-pack";
        push @dudes, map { " --reviewer=$_" } @reviewers;
        push @dudes, map { " --cc=$_" } @CCs;
        push @arguments, join('', @dudes); # Single argument to git push
    }
}

sub goto_gitdir()
{
    my $cdup = read_git_line('rev-parse', '--show-cdup');
    exit $? >> 8 if $?;
    chdir($cdup) unless $cdup eq "";
}

sub determine_target()
{
    # Detect tracking branch if ref-to is not set
    if ($ref_to eq "") {
        my $ref = $ref_from;
        $ref =~ s/[~^].*$//;
        my $sref = read_git_line("symbolic-ref", "-q", $ref);
        $ref = $sref if ($? == 0);
        $ref =~ s,^refs/heads/,,;
        read_git_line("rev-parse", "--verify", "-q", "refs/heads/".$ref);
        die "Cannot detect tracking branch, $ref is not a valid ref.\n" if ($? != 0);
        $ref_to = read_git_line("config", "branch.$ref.merge");
        die "Cannot detect tracking branch, 'git config branch.$ref.merge' failed.\n" if ($? != 0);
        $ref_to =~ s,^refs/heads/,,;
    }
}

sub push_patches()
{
    if (!$draft) {
        $_ = read_git_line('log', '--pretty=%s', '-1', $ref_from);
        exit $? >> 8 if ($? != 0);
        $draft = 1 if (/\bWIP\b|\*{3}|^(.)\1*$/i);
    }

    print "Pushing $ref_from for $ref_to on $remote ...\n" if (!$quiet);

    my @gitcmd = ("git", "push");
    push @gitcmd, '-v' if ($verbose);
    push @gitcmd, '-q' if ($quiet);
    push @gitcmd, '-n' if ($dry_run);
    push @gitcmd, @arguments;
    push @gitcmd, $remote, "$ref_from:refs/".($draft > 0 ? 'drafts' : 'for')."/$ref_to";

    print '+ '.format_cmd(@gitcmd)."\n" if ($debug);
    my $ex = system(@gitcmd);
    die("Failed to run \"git\": $!\n") if ($ex < 0);
    exit($ex >> 8) if ($ex);
}

load_aliases();
parse_arguments(@ARGV);
add_reviewers();
goto_gitdir();
determine_target();
push_patches();