path: root/.git-hooks/pre-commit

#!/usr/bin/env perl

# A hook script to verify what is about to be committed.
# Called by "git commit" with no arguments.  The hook should
# exit with non-zero status after issuing an appropriate message
# if it wants to stop the commit.

use strict;
use lib "solenv/clang-format";
#use File::Copy;
#use Cwd;

$ENV{LC_ALL} = "C";

sub check_whitespaces($)
{
    my ($h) = @_;
    my $src_limited = "bas|c|cpp|cxx|h|hrc|hxx|idl|inl|java|swift|map|MK|mm|pmk|pl|pm|sdi|sh|src|tab|ui|vb|xcu|xml|xsl|py";
    my $src_full = "bas|c|cpp|cxx|h|hrc|hxx|idl|inl|java|swift|map|mk|MK|mm|pmk|pl|pm|sdi|sh|src|tab|ui|vb|xcu|xml|xsl|py";

    my %modules = (basctl=>'basctl', chart2=>'chart', cui=>'cui', dbaccess=>'dba', desktop=>'dkt', editeng=>'editeng',
                   extensions=>'pcr', filter=>'flt', formula=>'for', fpicker=>'fps', framework=>'fwk', reportdesign=>'rpt',
                   sc=>'sc', sd=>'sd', sfx2=>'sfx', starmath=>'sm', svtools=>'svt', svx=>'svx', sw=>'sw', uui=>'uui',
                   vcl=>'vcl', writerperfect=>'wpt', xmlsecurity=>'xsc');

    my $found_bad = 0;
    my $filename;
    my $reported_filename = "";
    my $lineno;
    sub bad_line
    {
        my ($why, $line, $file_filter) = @_;
        if (!defined $file_filter || $filename =~ /\.($file_filter)$/)
        {
            if (!$found_bad)
            {
                print STDERR "*\n";
                print STDERR "* You have some suspicious patch lines:\n";
                print STDERR "*\n";
                $found_bad = 1;
            }
            if ($reported_filename ne $filename)
            {
                print STDERR "* In $filename\n";
                $reported_filename = $filename;
            }
            print STDERR "* $why (line $lineno)\n";
            print STDERR "$filename:$lineno:$line\n";
        }
    }
    open( FILES, "git diff-index -p -M --cached $h |" ) ||  die "Cannot run git diff-index.";
    while (<FILES>)
    {
        if (m|^diff --git a/(.*) b/\1$|)
        {
            $filename = $1;
            next;
        }
        if (/^@@ -\S+ \+(\d+)/)
        {
            $lineno = $1 - 1;
            next;
        }
        if (/^ /)
        {
            $lineno++;
            next;
        }
        if (s/^\+//)
        {
            $lineno++;
            chomp;
            if (/\s$/)
            {
                bad_line("trailing whitespace", $_ , $src_limited);
            }
            if (/\r$/)
            {
                bad_line("DOS lineends", $_ , $src_limited);
            }
            if (/\s*	/)
            {
                bad_line("indent with Tab", $_, $src_limited);
            }
            if (/^(?:[<>=]){7}$/)
            {
                bad_line("unresolved merge conflict", $src_full);
            }
            if (/SAL_DEBUG/)
            {
                bad_line("temporary debug in commit", $_, $src_limited);
            }
            if ((/OOXMLIMPORT/) and ($filename =~ /ooxmlexport/))
            {
                bad_line("OOXMLIMPORT definition used in a ooxmlexport file", $_, "cxx");
            }
            if ((/OOXMLEXPORT/) and ($filename =~ /ooxmlimport/))
            {
                bad_line("OOXMLEXPORT definition used in a ooxmlimport file", $_, "cxx");
            }
            if ((/<toolbar:toolbaritem/) and not(/\/>/))
            {
                bad_line("Use /> to close toolbar:toolbaritem", $_, "xml");
            }
            if (/<property name="use[-_]markup">True<\/property>/)
            {
                bad_line("use font attributes instead of use-markup", $_, "ui");
            }
            if (/<property name="tooltip[-_]markup"/ )
            {
                bad_line("use tooltip-text instead of tooltip_markup", $_, "ui");
            }
            if (/<property name="margin[-_]left"/ )
            {
                bad_line("use margin-start instead of margin-left", $_, "ui");
            }
            if (/<property name="margin[-_]right"/ )
            {
                bad_line("use margin-end instead of margin-right", $_, "ui");
            }
            if (/<object class="GtkAlignment"/)
            {
                bad_line("use margin-start (etc) on child instead of a GtkAlignment", $_, "ui");
            }
            if (/<property name="use[-_]stock"/ )
            {
                bad_line("use translation context 'stock' and the English string as button label instead", $_, "ui");
            }
            if (/<property name="stock[-_]id"/ )
            {
                bad_line("use an icon-name listed at https://developer.gnome.org/gtk3/stable/gtk3-Stock-Items.html", $_, "ui");
            }
            if (/<property name="stock"/ )
            {
                bad_line("use an icon-name listed at https://developer.gnome.org/gtk3/stable/gtk3-Stock-Items.html", $_, "ui");
            }
            if ((/translatable="yes"/) and not(/context=/))
            {
                bad_line("translatable .ui file line without context", $_, "ui");
            }
            if ((/requires/) and (/lib="gtk+/) and not (/version="3.20/))
            {
                bad_line("min supported version of gtk3 is 3.20", $_, "ui");
            }
            if ((/<interface/) and not(/domain=/))
            {
                bad_line(".ui file without translation domain", $_, "ui");
            }
            if (/<interface domain=/)
            {
                foreach my $key (keys %modules) {
                    if ((rindex($filename, $key, 0) == 0) and not (/$modules{$key}/))
                    {
                        bad_line("interface domain should be '$modules{$key}'", $_, "ui");
                    }
                }
            }
        }
    }
    if ( $found_bad)
    {
        exit($found_bad);
    }
}

sub check_author()
{
    my $author = `git var GIT_AUTHOR_IDENT`;
    chomp $author;
    if ($author =~ /^Your Name <you\@example.com>/)
    {
        print("ERROR: You have a suspicious author identity: '$author'\n");
        exit(1);
    }
}

sub check_style($)
{
    if (! -e "solenv/clang-format/ClangFormat.pm")
    {
        # Commit happens in a submodule.
        return;
    }

    require ClangFormat;
    ClangFormat->import();

    my ($h) = @_;
    my $src = ClangFormat::get_extension_regex();
    my @bad_names = ();
    my @bad_renames = ();
    my $clang_format = ClangFormat::find();

    ## Check if ClangFormat has get_excludelist or the old
    ## get_blacklist
    my $excluded_list_names;
    eval    { ClangFormat::get_excludelist() };
    if ($@) { $excluded_list_names = ClangFormat::get_blacklist(); }
    else    { $excluded_list_names = ClangFormat::get_excludelist(); }

    # Get a list of renamed files.
    my %renames; # key is target pathname, value is source pathname
    open (IN, "git diff-index --cached --find-renames --diff-filter=R --name-status $h |")
        || die "Cannot run git diff.";
    while (my $line = <IN>)
    {
        chomp $line;
        $line =~ /^[^\t]+\t([^\t]+)\t([^\t]+)$/ ||  die "Unexpected response line: $line";
        $renames{$2} = $1;
    }

    # Get a list of non-deleted changed files.
    open (FILES, "git diff-index --cached --diff-filter=AM --name-only $h |") ||  die "Cannot run git diff.";
    while (my $filename = <FILES>)
    {
        chomp $filename;
        if ($filename =~ /\.($src)$/ and !exists($excluded_list_names->{$filename}))
        {
            if (!defined($clang_format))
            {
                my $version = ClangFormat::get_wanted_version();
                my $opt_lo = ClangFormat::get_own_directory();

                print("\nWARNING: Commit touches new (non-excluded) files, but no clang-format"
                      . " ${version}\n");
                print(" found (via CLANG_FORMAT or PATH env vars, or in ${opt_lo}).\n\n");

                my $platform = "linux64";
                my $download = "wget";
                if ($^O eq "cygwin")
                {
                    $platform = "win.exe";
                }
                elsif ($^O eq "darwin")
                {
                    $platform = "mac";
                    $download = "curl -O";
                }

                print("To get a suitable binary, please do:\n\n");
                print("mkdir -p $opt_lo\n");
                print("cd $opt_lo\n");
                print("$download https://dev-www.libreoffice.org/bin/clang-format-$version-$platform\n");
                print("cp clang-format-$version-$platform clang-format\n");
                print("chmod +x clang-format\n\n");

                print("(Or read solenv/clang-format/README on how to build it yourself.\n");
                return;
            }
            if (!ClangFormat::check_style($clang_format, $filename))
            {
                if (defined($renames{$filename}))
                {
                    push @bad_renames, $filename;
                }
                else
                {
                    push @bad_names, $filename;
                }
            }
        }
    }

    # Enforce style.
    if (scalar @bad_names || scalar @bad_renames)
    {
        my $autostyle = `git config libreoffice.autostyle`;
        chomp $autostyle;
        if ($autostyle ne "true" or scalar @bad_renames)
        {
            print("\nThe above differences were found between the code to commit \n");
            print("and the clang-format rules.\n");
            if (scalar @bad_names)
            {
                print("You can apply these changes with:\n");
                print("\n$clang_format -i " . join(" ", @bad_names) . "\n\n");
            }
            if (scalar @bad_renames)
            {
                print("\nATTENTION: Of files detected as renamed by git, the following ones are\n");
                print("not clang-format'ed and are not listed in the excludelist. If they are\n");
                print("renames of previously excluded files, they should be added to the\n");
                print("excludelist:\n\n");
                foreach my $name (@bad_renames)
                {
                    if (exists($excluded_list_names->{$renames{$name}}))
                    {
                        print("* $name got renamed from $renames{$name},\n");
                        print("    which is even still listed in the excludelist!\n");
                    }
                    else
                    {
                        print("* $name\n");
                    }
                }
                print("\n");
            }
            print("Aborting commit. Apply changes and commit again or skip checking\n");
            print("with --no-verify (not recommended).\n");
            exit(1);
        }
        else
        {
            # 'git config libreoffice.autostyle true' was invoked to run
            # clang-format automatically.
            print("\nThe above differences were found between the code to commit \n");
            print("and the clang-format rules. Fixing these now automatically.\n");
            print("Running '$clang_format -i " . join(" ", @bad_names) . "' for you...\n");
            system("$clang_format -i " . join(" ", @bad_names));
            # TODO this stages all local modifications, staging originally
            # unstaged hunks.
            system("git add " . join(" ", @bad_names));
            print("Done.\n");
        }
    }
}

sub check_submodules($)
{
    my ($h) = @_;

    my $toplevel = `git rev-parse --show-toplevel`;
    chomp $toplevel;

    # trick to get a list of submodules - directly read from the .gitmodules
    open(SUBMODULES, "git config --file '$toplevel'/.gitmodules --get-regexp path | awk '{ print \$2 }' |" ) ||  die "Cannot run git config on the .gitmodules.";
    while (<SUBMODULES>)
    {
        chomp;

        my $ignore = `git config submodule.$_.ignore`;
        chomp $ignore;
        if ($ignore eq 'all')
        {
            print <<EOM;
Error: Your git configuration has submodule.$_.ignore set to 'all'.

This is dangerous and can lead to accidentally pushing unwanted changes to
submodules.

To fix it, please do:

  git config --unset submodule.$_.ignore

EOM
            exit(1);
        }

        my $diff = `git diff --cached --name-only -z $h -- $_`;
        chomp $diff;
        if ($diff ne '')
        {
            print <<EOM;
Error: You are trying to commit changes to submodule $_ from the main repo.

Please do not do that, commit only to the submodule, the git hook on the
server will make sure the appropriate change is mirrored in the main repo.

To remove the change, you can do:

  git submodule update $_

If it fails with 'error: Server does not allow request for unadvertised object',
run the following:

  git submodule sync
  git submodule update $_

EOM
            exit(1);
        }
    }
}

# Do the work :-)

# Initial commit: diff against an empty tree object
my $against="4b825dc642cb6eb9a060e54bf8d69288fbee4904";
if ( system( "git rev-parse --verify HEAD >/dev/null 2>&1" ) == 0 )
{
    $against="HEAD"
}

# If you want to allow non-ascii filenames set this variable to true.
my $allownonascii=`git config hooks.allownonascii`;
chomp $allownonascii;

# Cross platform projects tend to avoid non-ascii filenames; prevent
# them from being added to the repository. We exploit the fact that the
# printable range starts at the space character and ends with tilde.
if ( $allownonascii ne "true" &&
    # Note that the use of brackets around a tr range is ok here, (it's
    # even required, for portability to Solaris 10's /usr/bin/tr), since
    # the square bracket bytes happen to fall in the designated range.
    `git diff --cached --name-only --diff-filter=A -z $against | \
     LC_ALL=C tr -d '[ -~]\\0'` ne "" )
{
    print <<EOM;
Error: Attempt to add a non-ascii file name.

This can cause problems if you want to work
with people on other platforms.

To be portable it is advisable to rename the file ...

If you know what you are doing you can disable this
check using:

  git config hooks.allownonascii true

EOM
    exit( 1 );
}

# Block large files.
open( FILES, "git diff --cached --name-only --diff-filter=A -z $against |" ) ||  die "Cannot run git diff-index.";
while (<FILES>)
{
    if (/\.ui$/) # .ui files can get large
    {
        continue;
    }
    if (/\.xsl$/) # XSLT
    {
        continue;
    }
    my $size = `git cat-file -s :$_`;
    # For now let's say large is 500KB
    my $limit = 500;
    if ($size > $limit * 1024)
    {
        print "Error: Attempt to add a large file: $_, pleasy try to fit into $limit KB.\n";
        exit( 1 );
    }
}

# fix whitespace in code
check_whitespaces( $against);

# fix style in code
check_style($against);

# catch missing author info
check_author();

# catch commits to the submodules
check_submodules($against);

# all OK
exit( 0 );
# vi:set shiftwidth=4 expandtab: