[mirror_ubuntu-zesty-kernel.git] / debian / scripts / misc / git-ubuntu-log

#!/usr/bin/perl -w

use strict;
use Text::Wrap;

my $kernel_auth = "Upstream Kernel Changes";

my (%map, @reverts);
my $pstate = 1;
my $no_kern_log = 0;
my $print_shas = 0;
my $first_print = 1;

while (@ARGV) {
        my $opt = $ARGV[0];
        shift;
        if ($opt eq "--no-kern-log") {
                $no_kern_log = 1;
        } elsif ($opt eq "--print-shas") {
                $print_shas = 1;
        } else {
                print STDERR "Unknown options: $opt\n";
                exit(1);
        }
}

sub check_reverts($) {
        my ($entry) = @_;
        my ($check);

        foreach $check (reverse @reverts) {
                my $desc = "Revert \"" . $entry->{'desc'} . "\"";
                if ($check->{'desc'} eq $desc) {
                        @reverts = grep($_->{'desc'} ne $desc, @reverts);
                        return 1;
                }
        }

        return 0;
}

sub add_entry($) {
        my ($entry) = @_;
        my $key = $entry->{'author'};

        # store description in array, in email->{desc list} map
        if (exists $map{$key}) {
                # grab ref
                my $obj = $map{$key};

                # add desc to array
                push(@$obj, $entry);
        } else {
                # create new array, containing 1 item
                my @arr = ($entry);

                # store ref to array
                $map{$key} = \@arr;
        }
}

sub shortlog_entry($$$$$) {
        my ($name, $desc, $bug, $cve, $commit) = @_;
        my $entry;

        $desc =~ s#/pub/scm/linux/kernel/git/#/.../#g;
        $desc =~ s#\[PATCH\] ##g;

        $desc =~ s#^\s*##g;
        $desc =~ s# *UBUNTU: ##g;

        $entry->{'desc'} = $desc;
        if ($bug ne '') {
                $entry->{'bugno'} = $bug;
        }
        $entry->{'cve'} = $cve;
        $entry->{'commit'} = $commit;
        $entry->{'author'} = $name;

        if ($desc =~ /^Revert "/) {
                push(@reverts, $entry);
                return;
        }

        return if check_reverts($entry);

        add_entry($entry);
}

# sort comparison function
sub by_name($$) {
        my ($a, $b) = @_;

        uc($a) cmp uc($b);
}

sub shortlog_output {
        my ($obj, $key, $entry);

        foreach $key (sort by_name keys %map) {
                next if $key eq $kernel_auth and $no_kern_log;

                print "\n" unless $first_print;
                $first_print = 0;

                # output author
                printf "  [ %s ]\n\n", $key;

                # output author's 1-line summaries
                $obj = $map{$key};
                foreach $entry (reverse @$obj) {
                        print wrap("  * ", "    ", $entry->{'desc'}) . "\n";
                        # For non upstream changes, add other info.
                        if ($key ne $kernel_auth) {
                                if ($print_shas) {
                                        print "    - GIT-SHA " . $entry->{'commit'} .
                                                "\n";
                                }
                        }
                        if (defined($entry->{'bugno'})) {
                                print "    - LP: #" .  $entry->{'bugno'} . "\n";
                        }
                        if (defined($entry->{'cve'})) {
                                print "    - " . $entry->{'cve'} . "\n";
                        }
                }
        }
}

sub changelog_input {
        my ($author, $desc, $commit, $entry, $cve);

        while (<STDIN>) {
                # get commit
                if ($pstate == 1) {
                        next unless /^commit (.*)/;

                        $commit = $1;

                        $pstate++;
                }

                # get author and email
                elsif ($pstate == 2) {
                        my ($email);

                        next unless /^[Aa]uthor:?\s*(.*?)\s*<(.*)>/;

                        $author = $1;
                        $email = $2;
                        $desc = undef;
                        $cve = undef;

                        # cset author fixups
                        if (!$author) {
                                $author = $email;
                        }
                        $pstate++;
                }

                # skip to blank line
                elsif ($pstate == 3) {
                        next unless /^\s*$/;
                        $pstate++;
                }

                # skip to non-blank line
                elsif ($pstate == 4) {
                        next unless /^\s*?(.*)/;
                        my $ignore = 0;
                        my $do_ignore = 0;
                        my $bug = undef;
                        my %bugz = ();
                        my $k;

                        # skip lines that are obviously not
                        # a 1-line cset description
                        next if /^\s*From: /;

                        chomp;
                        $desc = $1;

                        if ($desc =~ /^ *(Revert "|)UBUNTU:/) {
                                $do_ignore = 1;
                        } else {
                                $do_ignore = 0;
                                $author = $kernel_auth;
                                $ignore = 1 if $desc =~ /Merge /;
                        }
                        while (<STDIN>) {
                                $ignore  =  1 if ($do_ignore && /^ *Ignore: yes/i);
                                if    (/^ *Bug: *(#|)([0-9#,\s]*)\s*$/i) {
                                        foreach $k (split('(,|\s)\s*(#|)', $2)) {
                                                $bugz{$k} = 1 if (($k ne '') and ($k =~ /[0-9]+/));
                                        }
                                }
                                elsif (/^ *BugLink: *http.*:\/\/.*\/([0-9]+)/i) {
                                        $bugz{$1} = 1;
                                }
                                elsif (/^ *(CVE-.*)/) {
                                        $cve = $1
                                }
                                last if /^commit /;
                        }

                        $bug = join(", #", sort keys(%bugz));
                        if (!$ignore) {
                                &shortlog_entry($author, $desc, $bug,
                                                $cve, $commit, 0);
                        }

                        $pstate = 1;
                        if ($_ && /^commit (.*)/) {
                                $commit = $1;
                                $pstate++;
                        }
                }
        
                else {
                        die "invalid parse state $pstate";
                }
        }

        foreach $entry (@reverts) {
                add_entry($entry);
        }       
}

&changelog_input;
&shortlog_output;

exit(0);