Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

my sub datetimize(Int() $epoch, $offset --> DateTime:D) {
    my int $hour    = $offset.substr(0,3).Int;
    my int $minutes = $offset.substr(3).Int;
    my int $timezone = $hour * 3600;
    $timezone += 60 * ($timezone < 0 ?? -$minutes !! $minutes);
    DateTime.new: $epoch, :$timezone, :formatter({
        my int $tz = .timezone;
        sprintf '%4d-%02d-%02d %2d:%02d:%02d %s%02d%02d',
          .year, .month, .day, .hour, .minute, .second,
          $tz < 0 ?? '-' !! '+',
          $tz.abs div 3600,
          ($tz.abs mod 3600) div 60
    })
}

my sub shortened-sha($sha) { $sha.substr(0,8) }

# Gather common information about a commit
class Git::Commit {
    has Str      $.sha;
    has Str      $.author;
    has Str      $.author-mail;
    has Str      $.committer;
    has Str      $.committer-mail;
    has Str      $.summary;
    has Str      $.previous-sha;
    has Str      $.previous-filename;
    has DateTime $.author-time;
    has DateTime $.committer-time;
    has          $!lock;
    has          %!blames;

    method TWEAK(:$filename --> Nil) {
        $!lock := Lock.new;
        %!blames{$filename} = [];
    }

    method add-blame($blame) {
        $!lock.protect: {
            %!blames{$blame.filename}.push: $blame;
        }
    }

    method blames() { %!blames.Map }
}

# Information about a single line of blame
class Git::Blame::Line {
    has Int         $.line-number,
    has Int         $.original-line-number,
    has Str         $.filename;
    has Str         $.line;
    has Git::Commit $.commit handles <sha author author-mail committer
      committer-mail summary previous author-time committer-time>;

    method Str() {
        "$.sha.substr(0,8) ($.author $.author-time "
          ~ $!line-number  # for now
#          ~ sprintf('%4d',$!line-number)  # need to figure out width
          ~ ") $!line"
    }
    method gist() { self.Str }
}

# All the blame information about a single file
class Git::Blame::File {
    has @.lines   is built(False);
    has %!commits;

    multi method new(Git::Blame::File: $file --> Git::Blame::File:D) {
        self.bless: :$file, :commits(Hash.new)
    }

    method TWEAK(:$file, :$commits is raw --> Nil) {
        %!commits := $commits;

        my $io     := $file.IO;
        my $parent := $io.parent;
        my $proc;
        my $iterator := indir $parent, {
            $proc := run <git blame --porcelain>, $io.basename, :out, :err;
            $proc.out.lines.iterator
        }

        my $lines := IterationBuffer.new;
        $lines.push: Nil;  # lines[] is 1-based
        my $sha;
        my $filename;
        my $commit;
        my Int() $todo;
        my Int() $original-line-number;
        my Int() $line-number;

        until (my $porcelain := $iterator.pull-one) =:= IterationEnd {

            # still in a chunk
            if $todo {
                ($sha, $original-line-number, $line-number) =
                  $porcelain.words;
                $porcelain := $iterator.pull-one;
                die "weird end" unless $porcelain.starts-with("\t");

                $commit = %!commits{$sha}
                  // die "No commit for '$sha' found";
            }

            # first chunk or chunk ended
            else {
                ($sha, $original-line-number, $line-number, $todo) =
                  $porcelain.words;

                with %!commits{$sha} {
                    $commit = $_;
                    $porcelain := $iterator.pull-one;
                    die "weird end" unless $porcelain.starts-with("\t");
                }
                else {
                    my %fields;
                    until ($porcelain := $iterator.pull-one) =:= IterationEnd
                      || $porcelain.starts-with("\t") {
                        my ($key, $value) = $porcelain.split(" ", 2);
                        %fields{$key} := $value;
                    }
                    die "unexpected end" unless $porcelain.starts-with("\t");

                    with %fields<author-time> {
                        $_ = datetimize $_, %fields<author-tz>:delete;
                    }
                    with %fields<committer-time> {
                        $_ = datetimize $_, %fields<committer-tz>:delete;
                    }
                    with %fields<previous>:delete {
                        %fields<previous-sha previous-filename> = .words;
                    }
                    $filename = %fields<filename>;
                    $commit = %!commits{$sha} :=
                      Git::Commit.new: :$sha, |%fields;
                }
            }

            # all ready to process this line of blame
            my $blame := Git::Blame::Line.new:
              :line($porcelain.substr(1)),  # skip TAB
              :$sha, :$original-line-number, :$line-number,
              :$filename, :$commit;
            $commit.add-blame: $blame;
            $lines.push: $blame;
            --$todo;
        }

        if $proc.err.slurp -> $error {
            return $error.Failure;
        }
        @!lines := $lines.List;
    }

    method commits() { %!commits.Map }
}



Git::Blame::File - Who did what and when on a file in a Git repository


=begin code :lang<raku>

use Git::Blame::File;

my $blamer = Git::Blame::File.new( "t/target" );
say $blamer.lines[3];
# c64c97c3 (Elizabeth Mattijsen 2022-07-27 20:40:22 +0200 3) And this the third line

=end code


Git::Blame is a module that uses C<git blame> to extract information from a single file in a
Git repository and process it in a number of ways. It's mainly geared to tally contributions
via lines changed, but it can also be modified and used to do some repository mining.


It works, for the time being, with single files.


Returns an Array with all the lines in the file (1-based).


Source can be located at: https://github.com/lizmat/Git-Blame-File .
Comments and Pull Requests are welcome.


If you like this module, or what I’m doing more generally, committing to a
L<small sponsorship|https://github.com/sponsors/lizmat/>  would mean a great
deal to me!


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


File

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

METHODS

lines()

AUTHORS

COPYRIGHT AND LICENSE

Git::Blame::File v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation