File Coverage

blib/lib/Git/Hooks.pm

Criterion	Covered	Total	%
statement	61	139	43.8
branch	0	46	0.0
condition	3	14	21.4
subroutine	14	20	70.0
pod	5	5	100.0
total	83	224	37.0

use warnings;

package Git::Hooks;
# ABSTRACT: Framework for implementing Git (and Gerrit) hooks
$Git::Hooks::VERSION = '3.4.0';
use v5.16.0;
use utf8;
use Carp;
use Exporter qw/import/;
use Path::Tiny;
use Log::Any '$log';
use Git::Repository qw/GitHooks Log/;

our @EXPORT; ## no critic (Modules::ProhibitAutomaticExportation)

my %Hooks;

BEGIN {                         ## no critic (RequireArgUnpacking)
    my @directives =
        qw/ APPLYPATCH_MSG PRE_APPLYPATCH POST_APPLYPATCH
            PRE_COMMIT PREPARE_COMMIT_MSG COMMIT_MSG
            POST_COMMIT PRE_REBASE POST_CHECKOUT POST_MERGE
            PRE_PUSH PRE_RECEIVE UPDATE POST_RECEIVE POST_UPDATE
            PUSH_TO_CHECKOUT PRE_AUTO_GC POST_REWRITE

            REF_UPDATE PATCHSET_CREATED DRAFT_PUBLISHED
            COMMIT_RECEIVED SUBMIT
          /;

    my @drivers =
        qw/ GITHOOKS_CHECK_AFFECTED_REFS
            GITHOOKS_CHECK_PRE_COMMIT
            GITHOOKS_CHECK_PATCHSET
            GITHOOKS_CHECK_MESSAGE_FILE
          /;

    for my $directive (@directives) {
        my $hook = $directive;
        $hook =~ tr/A-Z_/a-z-/;
        no strict 'refs';       ## no critic (ProhibitNoStrict)
        *{"Git::Hooks::$directive"} = sub (&) {
            push @{$Hooks{$hook}}, {
                package => scalar(caller),
                sub     => shift(@_),
            };
        }
    }

    @EXPORT = (@directives, @drivers, 'run_hook');
}

sub GITHOOKS_CHECK_AFFECTED_REFS (&;$) {
    my ($check_ref, $options) = @_;
    $options //= {};
    my $caller = caller;

    my $hook = {
        package => $caller,
        sub     => sub {
            my ($git) = @_;

            $log->debug("$caller(GITHOOKS_CHECK_AFFECTED_REFS)");

            $options->{config}($git) if exists $options->{config};

            return 1 if $git->im_admin();

            my $errors = 0;

            foreach my $ref ($git->get_affected_refs()) {
                next unless $git->is_reference_enabled($ref);
                $errors += $check_ref->($git, $ref);
            }

            $options->{destroy}($git) if exists $options->{destroy};

            return $errors == 0;
        },
    };

    foreach my $name (qw/commit-received pre-receive ref-update submit update/) {
        push @{$Hooks{$name}}, $hook;
    }

    return;
}

sub GITHOOKS_CHECK_PRE_COMMIT (&;$) {
    my ($check_commit, $options) = @_;
    $options //= {};
    my $caller = caller;

    my $hook = {
        package => $caller,
        sub     => sub {
            my ($git) = @_;

            $log->debug("$caller(GITHOOKS_CHECK_COMMIT)");

            return 1 if $git->im_admin();

            $options->{config}($git) if exists $options->{config};

            my $current_branch = $git->get_current_branch();

            return 1 unless $git->is_reference_enabled($current_branch);

            my $errors = $check_commit->($git, $current_branch);

            $options->{destroy}($git) if exists $options->{destroy};

            return $errors == 0;
        },
    };

    foreach my $name (qw/pre-applypatch pre-commit/) {
        push @{$Hooks{$name}}, $hook;
    }

    return;
}

sub GITHOOKS_CHECK_PATCHSET (&;$) {
    my ($check_patchset, $options) = @_;
    $options //= {};
    my $caller = caller;

    my $hook = {
        package => $caller,
        sub     => sub {
            my ($git, $opts) = @_;

            $log->debug("$caller(GITHOOKS_CHECK_PATCHSET)");

            return 1 if $git->im_admin();

            $options->{config}($git) if exists $options->{config};

            my $sha1   = $opts->{'--commit'};
            my $commit = $git->get_commit($sha1);

            # The --branch argument contains the branch short-name if it's in the
            # refs/heads/ namespace. But we need to always use the branch long-name,
            # so we change it here.
            my $branch = $opts->{'--branch'};
            $branch = "refs/heads/$branch"
                unless $branch =~ m:^refs/:;

            return 1 unless $git->is_reference_enabled($branch);

            my $errors = $check_patchset->($git, $branch, $commit);

            $options->{destroy}($git) if exists $options->{destroy};

            return $errors == 0;
        },
    };

    foreach my $name (qw/draft-published patchset-created/) {
        push @{$Hooks{$name}}, $hook;
    }

    return;
}

sub GITHOOKS_CHECK_MESSAGE_FILE (&;$) {
    my ($check_message_file, $options) = @_;
    $options //= {};
    my $caller = caller;
    (my $cfg = $caller) =~ s/.*::/githooks./;

    my $hook = {
        package => $caller,
        sub     => sub {
            my ($git, $commit_msg_file) = @_;

            $log->debug("$caller(GITHOOKS_CHECK_MESSAGE_FILE)");

            return 1 if $git->im_admin();

            $options->{config}($git) if exists $options->{config};

            my $current_branch = $git->get_current_branch();

            return 1 unless $git->is_reference_enabled($current_branch);

            my $msg = eval {$git->read_commit_msg_file($commit_msg_file)};

            unless (defined $msg) {
                $git->fault(<<"EOS", {details => $@});
I cannot read the commit message file '$commit_msg_file'.
EOS
                return 0;
            }

            my $errors = $check_message_file->($git, $msg, $current_branch);

            $options->{destroy}($git) if exists $options->{destroy};

            return $errors == 0;
        },
    };

    foreach my $name (qw/applypatch-msg commit-msg/) {
        push @{$Hooks{$name}}, $hook;
    }

    return;
}

# This is the main routine of Git::Hooks. It gets the original hook
# name and arguments, sets up the environment, loads plugins and
# invokes the appropriate hook functions.

sub run_hook {
    my ($hook_name, @args) = @_;

    my $hook_basename = path($hook_name)->basename;

    # Contextualize the logs with the PID on server hooks. However, note that
    # the Log::Any::context method was implemented on Log::Any version 1.050.
    $log->context->{pid} = $$
        if $hook_basename =~ /^(?:(pre|post)?-receive|(post-)?update|push-to-checkout)$/
        && $log->can('context');

    $log->info("run_hook($hook_basename)", {args => \@args});

    my $git = Git::Repository->new();

    local $ENV{GITHOOKS_AUTHENTICATED_USER} = $git->authenticated_user();

    $git->prepare_hook($hook_name, \@args);

    $git->load_plugins();

    # Call every hook function installed by the hook scripts before.
    for my $hook (@{$Hooks{$hook_basename}}) {
        my $ok = eval { $hook->{sub}->($git, @args) };
        if (defined $ok) {
            # Modern hooks return a boolean value indicating their success.
            # If they fail they invoke
            # Git::Repository::Plugin::GitHooks::fault.
            unless ($ok) {
                # Let's see if there is a help-on-error message configured
                # specifically for this plugin.
                my $CFG = $hook->{package} =~ s/.*::/githooks./r;
                if (my $help = $git->get_config(lc $CFG => 'help-on-error')) {
                    $git->fault($help, {prefix => $hook->{package}});
                }
            }
        } elsif (length $@) {
            # Old hooks die when they fail...
            $git->fault("Hook failed", {
                prefix  => __PACKAGE__ . "($hook_basename)",
                details => $@,
            });
        } else {
            # ...and return undef when they succeed.
        }
    } continue {
        $git->check_timeout();
    }

    # Invoke enabled external hooks. This doesn't work in Windows yet.
    $git->invoke_external_hooks(@args);

    # Some hooks want to do some post-processing
    foreach my $post_hook ($git->post_hooks) {
        $post_hook->($hook_basename, $git, @args);
    } continue {
        $git->check_timeout();
    }

    $git->fail_on_faults(
        ($hook_basename eq 'commit-msg' or $hook_basename eq 'pre-commit')
        and not $git->get_config_boolean(githooks => 'abort-commit')
    );

    return;
}


1; # End of Git::Hooks

__END__