File Coverage

blib/lib/Git/MoreHooks/CheckIndent.pm

Criterion	Covered	Total	%
statement	36	111	32.4
branch	3	24	12.5
condition	4	21	19.0
subroutine	9	15	60.0
pod	0	3	0.0
total	52	174	29.8

## no critic (Documentation::PodSpelling)
## no critic (Documentation::RequirePodAtEnd)
## no critic (Documentation::RequirePodSections)
## no critic (ValuesAndExpressions::RequireInterpolationOfMetachars)
## no critic (Subroutines::RequireArgUnpacking)

package Git::MoreHooks::CheckIndent;

use strict;
use warnings;
use utf8;

# ABSTRACT: Check committed files for problems with indentation.

our $VERSION = '0.016'; # VERSION: generated by DZP::OurPkgVersion

use Git::MoreHooks::CheckCommitBase \&do_hook;

use Git::Hooks 3.000000;
use Path::Tiny;
use Log::Any qw{$log};
use Params::Validate qw(:all);

my $PKG = __PACKAGE__;
my ($CFG) = __PACKAGE__ =~ /::([^:]+)$/msx;
$CFG = 'githooks.' . $CFG;

####################
# Hook configuration, check it and set defaults.

sub _setup_config {
    my ($git) = @_;
    $log->debugf( __PACKAGE__ . '::_setup_config(%s):', '$git' );

    my $config = $git->get_config();
    $log->tracef( __PACKAGE__ . '::_setup_config(): Current Git config:\n%s.', $config );

    # Put empty hash if there is no config items.
    $config->{ lc $CFG } //= {};

    # Set default config values.
    my $default = $config->{ lc $CFG };
    $default->{'file'}      //= [];
    $default->{'exception'} //= [];

    # Check validity of config items.
    foreach my $file_def ( @{ $default->{'file'} } ) {
        $log->debugf( __PACKAGE__ . q{::} . '_setup_config(): Check for validity, config item: \'%s\'.', $file_def );
        if (
            ## no critic (RegularExpressions::ProhibitComplexRegexes)
            $file_def !~ m{^
            (?:[[:graph:]]+)
            (?:
                (?:[[:space:]]{1,}indent-size:[[:digit:]]+){1,}
                | (?:[[:space:]]{1,}indent-char:(?:space|tab|both))
            ){1,}
            (?:[[:space:]]{0,})
            $}msx
            ## use critic (RegularExpressions::ProhibitComplexRegexes)
          )
        {
            $git->error( $PKG, 'Faulty config item: \'' . $file_def . '\'.' );
            return 0;
        }
    }
    foreach my $exc_def ( @{ $default->{'exception'} } ) {
        $log->debugf( __PACKAGE__ . q{::} . '_setup_config(): Check for validity, config item: \'%s\'.', $exc_def );
        if (
            ## no critic (RegularExpressions::ProhibitComplexRegexes)
            $exc_def !~ m{^
            (?:[[:space:]]{0,})   (?# Free spacing before)
            (?:[[:graph:]]+)      (?# File name pattern)
            (?:[[:space:]]{1,})   (?# Required spacing)
            (?:[[:graph:]]+)      (?# Regular expression)
            (?:[[:space:]]{0,})   (?# Free spacing after)
            $}msx
            ## use critic (RegularExpressions::ProhibitComplexRegexes)
          )
        {
            $git->error( $PKG, 'Faulty config item: \'' . $exc_def . '\'.' );
            return 0;
        }
    }
    return 1;
}

####################
# Internal functions

sub check_for_indent {
    my %params = validate(
        @_,
        {
            file_as_string => { type => SCALAR, },
            indent_char    => {
                type    => SCALAR,
                default => q{ },
                regex   => qr/[[:space:]]{1,}/msx,
            },
            indent_size => {
                type    => SCALAR,
                default => 4,
                regex   => qr/[[:digit:]]{1,}/msx,
            },
            exceptions => {
                type    => ARRAYREF,
                default => [],
            },
        },
    );
    my $ic     = $params{'indent_char'};
    my $row_nr = 1;
    my %errors;
    foreach my $row ( split qr/\n/msx, $params{'file_as_string'} ) {

        # Check for faulty tab chars (space/tab)
        my ($indents) = $row =~ m/^([[:space:]]{0,})/msx;
        if (
            length $indents > 0
            && ( $indents !~ m/^[$ic]{1,}$/msx
                || ( ( $ic ne qq{\t} ) && ( length $indents ) % $params{'indent_size'} != 0 ) )
          )
        {
            # If there is an exception regexp that matches this row,
            # then skip logging it as error.
            if ( !map { $row =~ m/$_/msx } @{ $params{'exceptions'} } ) {
                $errors{$row_nr} = $row;
            }
            else {
                $log->debugf( __PACKAGE__ . q{::} . 'check_for_indent(): Except this row: \'%s\'', $row );
            }
        }
        $row_nr++;
    }
    return %errors;
}

####################
# Callback function

sub do_hook {
    my ( $git, $hook_name, $opts ) = @_;
    $log->tracef( 'do_hook(%s)', ( join q{:}, @_ ) );

    return 1 if $git->im_admin();
    if ( !_setup_config($git) ) {
        return 0;
    }

    my $errors = 0;
    if ( $hook_name eq 'pre-commit' ) {
        my @files = $git->filter_files_in_index('AM');
        foreach my $file (@files) {
            my $read_file_func_ptr = sub { return path(shift)->slurp( { 'binmode' => ':raw' } ) };
            $errors += handle_file( $git, $file, $read_file_func_ptr, ':0' );
        }
    }
    elsif ( $hook_name eq 'patchset-created' || $hook_name eq 'draft-published' ) {
        my @files = $git->filter_files_in_commit( 'AM', $opts->{'gerrit-opts'}->{'--commit'} );
        foreach my $file (@files) {
            my $read_file_func_ptr = sub {
                my ( $file, $commit ) = @_;
                my $tmpfile_name = $git->blob( $commit, $file );
                return path($tmpfile_name)->slurp( { 'binmode' => ':raw' } );
            };
            $errors += handle_file( $git, $file, $read_file_func_ptr, $opts->{'gerrit-opts'}->{'--commit'} );
        }
    }
    elsif ( $hook_name eq 'update' || $hook_name eq 'pre-receive' || $hook_name eq 'ref-update' ) {
        foreach my $ref ( $git->get_affected_refs() ) {
            my ( $old_commit, $new_commit ) = $git->get_affected_ref_range($ref);
            my @files = $git->filter_files_in_range( 'AM', $old_commit, $new_commit );
            foreach my $file (@files) {
                my $read_file_func_ptr = sub {
                    my ( $file, $commit ) = @_;
                    my $tmpfile_name = $git->blob( $commit, $file );
                    return path($tmpfile_name)->slurp( { 'binmode' => ':raw' } );
                };
                $errors += handle_file( $git, $file, $read_file_func_ptr, $new_commit );
            }
        }
    }
    return $errors == 0;
}

sub handle_file {
    my ( $git, $filename, $read_file_func_ptr, $commit ) = @_;
    $log->tracef( 'handle_file(%s)', ( join q{:}, @_ ) );
    my @file_defs = $git->get_config( $CFG => 'file' );
    my %opts;
    my $errors = 0;
    foreach my $file_def (@file_defs) {
        my ( $file_regexp, $options ) = split q{ }, $file_def, 2;
        if ( $filename =~ m/$file_regexp/msx ) {
            ( $opts{'indent_size'} ) = $options =~ m/indent-size:([[:digit:]]+)/msx;
            ( $opts{'indent_char'} ) = $options =~ m/indent-char:(space|tab|both)/msx;
            my $file_as_string = &{$read_file_func_ptr}( $filename, $commit );
            my %exceptions;
            foreach my $exc_row ( $git->get_config( $CFG => 'exception' ) ) {
                my ( $exc_file_regexp, $exc ) = split qr{[[:space:]]+}msx, $exc_row;
                if ( $filename =~ m/$exc_file_regexp/msx ) {
                    $exceptions{$exc_file_regexp} = $exc;
                }
            }
            my %results = check_for_indent(
                'file_as_string' => $file_as_string,
                'indent_char'    => $opts{'indent_char'} eq 'space' ? q{ } : qq{\t},
                'indent_size'    => $opts{'indent_size'},
                'exceptions'     => [ values %exceptions ],
            );
            foreach my $row_nr ( keys %results ) {
                $git->error( $PKG, "Indent error ($commit, $filename:$row_nr): '$results{$row_nr}'" );
                $errors++;
            }
            last;
        }
    }
    return $errors;
}

1;

__END__