File Coverage

blib/lib/SVK/Log/Filter/Stats.pm

Criterion	Covered	Total	%
statement	9	9	100.0
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	12	12	100.0

package SVK::Log::Filter::Stats;

use strict;
use warnings;

use base qw( SVK::Log::Filter::Output );
use List::Util qw( max min minstr maxstr );
use Time::Local;

our $VERSION = '0.0.4';

sub setup {
    my ($self, $args) = @_;

    $self->{commits} = 0;
    $self->{committers} = {};
    $self->{files} = {};

    # hacks!
    $self->{newest_commit} = '';
    $self->{oldest_commit}   = '9999-99-99';
}

sub revision {
    my ($self, $args) = @_;
    my ($props, $changed_paths) = @{$args}{'props', 'paths'};

    my $date   = $props->{'svn:date'}   || q{};
    my $author = $props->{'svn:author'} || 'no author';

    # track the commit dates (usually from newest to oldest)
    $self->{newest_commit} = maxstr( $self->{newest_commit}, $date );
    $self->{oldest_commit} = minstr( $self->{oldest_commit}, $date );

    $self->{commits}++;
    $self->{committers}{$author}++;

    for my $changed_path ( $changed_paths->paths() ) {
        my $path = $changed_path->path();
        $self->{files}{$path}++;
    }

    return;
}

sub footer {
    my ($self, $args) = @_;
    my $stash = $args->{stash};

    my $quiet   = $stash->{quiet};
    my $verbose = $stash->{verbose};

    $self->newest_commit;
    $self->oldest_commit;
    print "Commits: ", $self->{commits}, "\n";

    $self->commits_per_day;

    my $author_count = $verbose ? 999_999 : 5;
    $self->author_details($author_count) if !$quiet;
    $self->file_details(5) if $verbose;

    if ($verbose) {
        print "Concentration:\n";
        $self->concentration_ratio;
        $self->herfindahl;
    }

    return;
}


sub newest_commit {
    my ($self) = @_;
    my $newest = substr($self->{newest_commit}, 0, 10);
    print "Newest commit : $newest\n";
}

sub oldest_commit {
    my ($self) = @_;
    my $oldest = substr($self->{oldest_commit}, 0, 10);
    print "Oldest commit : $oldest\n";
}

sub days {
    my ($self) = @_;
    my $young = _date_into_time( $self->{newest_commit} );
    my $old = _date_into_time( $self->{oldest_commit} );

    my $delta = $young - $old;
    my $days = int($delta/86400);
    print "Days: $days\n";
    return $days;
}

sub _date_into_time {
    my ($date) = @_;

    my ($y, $m, $d, $h, $min, $s, $ms) = split /[-T:.]/, $date;
    $m--;
    $y -= 1900;
    return timegm($s,$min,$h,$d,$m,$y);
}

sub commits_per_day {
    my ($self) = @_;

    my $days = $self->days;
    return if $days < 1;
    return if $self->{commits} < 1;

    my $c_per_day = $self->{commits} / $days;

    if ( $c_per_day > 1 ) {
        printf "Commits per day : %.1f\n", $c_per_day;
    }
    else {
        printf "Days per commit : %.1f\n", (1 / $c_per_day);
    }
}

sub author_details {
    my ($self, $count) = @_;
    $count ||= 5;

    # sort the committer list by commits
    my @committers;
    while ( my ($author, $commits) = each %{ $self->{committers} } ) {
        push @committers, [ $author, $commits ];
    }
    @committers = sort { $b->[1] <=> $a->[1] } @committers;

    print  "Committer count: ", (scalar @committers), "\n";

    # trim the list of committers
    my $count_index = min( $count-1, $#committers );
    @committers = @committers[ 0 .. $count_index ];

    # display the top committers
    my $longest = max map { length $_->[0] } @committers;
    print  "Most active committers:\n";
    foreach (@committers) {
        my ( $author, $count ) = @$_;
        $author .= ' 'x( $longest - length($author) );
        print "  - $author ($count)\n";
    }
}

sub file_details {
    my ($self, $count) = @_;
    $count ||= 5;

    # sort the file list by modifications
    my @files;
    while ( my ($path, $commits) = each %{ $self->{files} } ) {
        push @files, [ $path, $commits ];
    }
    @files = sort { $b->[1] <=> $a->[1] } @files;

    print "Count of modified paths: ", (scalar @files), "\n";

    # trim the list of files
    my $count_index = min( $count-1, $#files );
    @files = @files[ 0 .. $count_index ];

    # display the file details
    my $longest = max map { length $_->[0] } @files;
    print  "Most modified paths:\n";
    foreach (@files) {
        my ( $file, $count ) = @$_;
        $file .= ' 'x( $longest - length($file) );
        print "  - $file ($count)\n";
    }
}

sub concentration_ratio {
    my ($self) = @_;

    my $commit_count = $self->{commits};
    return if $commit_count < 1;

    my @committers;
    for my $commits ( values %{ $self->{committers} } ) {
        push @committers, $commits;
    }
    return if @committers < 4;
    @committers = sort { $b <=> $a } @committers;
    @committers = @committers[ 0 .. 3 ];  # get the top 4

    # find the total commits performed by the top 4
    my $commits_by_top = 0;
    for ( @committers ) {
        $commits_by_top += $_;
    }

    printf "  Concentration ratio : %.2f\n", ($commits_by_top / $commit_count);
}

sub herfindahl {
    my ($self) = @_;

    my $commit_count = $self->{commits};
    return if $commit_count < 1;

    my @committers;
    for my $commits ( values %{ $self->{committers} } ) {
        push @committers, $commits;
    }

    my $cumulative_herfindahl = 0;
    for ( @committers ) {
        $cumulative_herfindahl += ( $_ / $commit_count * 100 ) ** 2;
    }

    printf "  Herfindahl index : \%d\n", $cumulative_herfindahl;
    printf "  Normalized Herfindahl index : %.2f\n",
        ( $cumulative_herfindahl / 10_000 );
    printf "  Equivalent committers : %.1f\n",
        ( 10_000 / $cumulative_herfindahl );
}

1;

__END__