git_fame 1.7.2 → 2.0.0

data/lib/git_fame/blame_parser.rb

@@ -0,0 +1,83 @@
+# Extracted from the dolt gem. Currently not maintained.
+# Source: https://docs.omniref.com/ruby/gems/libdolt/0.33.14/symbols/Dolt::Git::Blame::PorcelainParser
+module GitFame
+  class BlameParser
+    def initialize(output)
+      @output = output
+      @commits = {}
+    end
+    def parse
+      lines = @output.split("\n")
+      chunks = []
+      while lines.length > 0
+        chunk = extract_header(lines)
+        affected_lines = extract_lines(lines, chunk[:num_lines])
+        if chunks.last && chunk[:oid] == chunks.last[:oid]
+          chunks.last[:lines].concat(affected_lines)
+        else
+          chunk[:lines] = affected_lines
+          chunks << chunk
+        end
+      end
+      chunks
+    rescue Exception => error
+      raise Error, "Failed parsing Procelain: #{error.message}"
+    end
+
+    def is_header?(line)
+      line =~ /^[0-9a-f]{40} \d+ \d+ \d+$/
+    end
+
+    def extract_header(lines)
+      header = lines.shift
+      pieces = header.scan(/^([0-9a-f]{40}) (\d+) (\d+) (\d+)$/).first
+      header = { :oid => pieces.first, :num_lines => pieces[3].to_i }
+      if lines.first =~ /^author/
+        header[:author] = extract_hash(lines, :author)
+        header[:committer] = extract_hash(lines, :committer)
+        header[:summary] = extract(lines, "summary")
+        header[:boundary] = extract(lines, "boundary")
+        throwaway = lines.shift until throwaway =~ /^filename/
+        @commits[header[:oid]] = header
+      else
+        header[:author] = @commits[header[:oid]][:author]
+        header[:committer] = @commits[header[:oid]][:committer]
+        header[:summary] = @commits[header[:oid]][:summary]
+      end
+      header
+    end
+
+    def extract_lines(lines, num)
+      extracted = []
+      num.times do
+        if extracted.length > 0
+          line = lines.shift # Header for next line
+        end
+        content = lines.shift # Actual content
+        next unless content
+        extracted.push(content[1..content.length]) # 8 spaces padding
+      end
+      extracted
+    end
+
+    def extract_hash(lines, type)
+      {
+        :name => extract(lines, "#{type}"),
+        :mail => extract(lines, "#{type}-mail").gsub(/[<>]/, ""),
+        :time => (Time.at(extract(lines, "#{type}-time").to_i).utc +
+        Time.zone_offset(extract(lines, "#{type}-tz")))
+      }
+    end
+    def extract(lines, thing)
+      if thing == "boundary"
+        if (line = lines.shift) == thing
+          return true
+        else
+          return ! lines.unshift(line)
+        end
+      end
+
+      lines.shift.split("#{thing} ")[1]
+    end
+  end
+end

data/lib/git_fame/commit_range.rb

@@ -0,0 +1,27 @@
+class CommitRange < Struct.new(:data, :current_branch)
+  SHORT_LENGTH = 7
+
+  def to_s(short = false)
+    @_to_s ||= range.map do |commit|
+      short ? shorten(commit) : commit
+    end.join("..")
+  end
+
+  def is_range?
+    data.is_a?(Array)
+  end
+
+  def range
+    is_range? ? data : [data]
+  end
+  
+  private
+
+  def branch?(commit)
+    current_branch == commit
+  end
+
+  def shorten(commit)
+    branch?(commit) ? commit : commit[0..SHORT_LENGTH]
+  end
+end

data/lib/git_fame/errors.rb

@@ -1,4 +1,6 @@
 module GitFame
-  class BranchNotFound < StandardError
+  class Error < StandardError
+  end
+  class NothingFound < StandardError
   end
 end

data/lib/git_fame/silent_progressbar.rb

@@ -1,11 +1,18 @@
-class SilentProgressbar < ProgressBar
+require "ruby-progressbar"
+
+class SilentProgressbar < ProgressBar::Base
   #
   # @name String Name for progressbar
   # @steps Fixnum Total number of steps
   # @active Should progressbar be visible?
   #
   def initialize(name, steps, active = false)
-    out =  active ? $stdout : File.new("/dev/null", "w")
-    super(name, steps, out)
+    output =  active ? $stdout : File.new("/dev/null", "w")
+    super({
+      title: name, 
+      total: steps, 
+      output: output,
+      smoothing: 0.6
+    })
   end
 end

data/lib/git_fame/version.rb

@@ -1,3 +1,3 @@
 module GitFame
-  VERSION = "1.7.2"
+  VERSION = "2.0.0"
 end

data/spec/bin_spec.rb

@@ -19,19 +19,21 @@ describe "bin/git-fame" do
     "--sort=name",
     "--sort=commits",
     "--sort=loc",
-    "--sort=files",
-    "--progressbar=0",
-    "--progressbar=1",
+    "--hide-progressbar",
     "--whitespace",
-    "--bytype",
+    "--by-type",
     "--include=hello",
     "--exclude=hello",
     "--extension=rb,ln",
     "--branch=master",
     "--format=csv",
     "--format=pretty",
+    "--before=2010-01-01",
+    "--after=1980-01-01",
     "--version",
-    "--help"
+    "--help",
+    "--verbose",
+    "--everything"
   ].each do |option|
     it "should support #{option}" do
       run(option).should be_a_succees
@@ -41,4 +43,65 @@ describe "bin/git-fame" do
   it "should sort by loc by default" do
     run("--sort=loc", "--progressbar=0").first.should eq(run("--progressbar=0").first)
   end
-end
+
+  context "dates" do
+    it "should fail on invalid before date" do
+      res = run("--before='---'")
+      res.should_not be_a_succees
+      res.first.should eq("Error: '---' is not a valid date\n")
+    end
+
+    it "should fail on invalid after date" do
+      res = run("--after='---'")
+      res.should_not be_a_succees
+      res.should include_output("Error: '---' is not a valid date\n")
+    end
+
+    it "should not print stack trace on invalid dates (--after)" do
+      res = run("--after='---'")
+      res.should_not be_a_succees
+      res.should_not include_output("GitFame::Error")
+    end
+
+    it "should not print stack trace on invalid dates (--before)" do
+      res = run("--before='---'")
+      res.should_not be_a_succees
+      res.should_not include_output("GitFame::Error")
+    end
+
+    it "should not print stack trace on out of span (--before)" do
+      res = run("--before='1910-01-01'")
+      res.should_not be_a_succees
+      res.should_not include_output("GitFame::Error")
+    end
+
+    it "should not print stack trace on out of span (--after)" do
+      res = run("--after='2100-01-01'")
+      res.should_not be_a_succees
+      res.should_not include_output("GitFame::Error")
+    end
+  end
+
+  context "sort" do
+    it "should fail on non existing option" do
+      run("--sort=-----").should_not be_a_succees
+    end
+
+    results = []
+    GitFame::SORT.each do |option|
+      it "should be able to sort by #{option}" do
+        out = run("--sort=#{option}")
+        out.should be_a_succees
+        # TODO: Not a impl. problem
+        # Just not enough data
+        unless option == "name"
+          results.push(out.first)
+        end
+      end
+    end
+
+    it "#{GitFame::SORT.join(", ")} should not output the same thing" do
+      results.uniq.sort.should eq(results.sort)
+    end
+  end
+end

data/spec/git_fame_spec.rb

@@ -1,33 +1,39 @@
 describe GitFame::Base do
-  let(:subject) { GitFame::Base.new({repository: repository}) }
+  let(:subject) { GitFame::Base.new({ repository: repository }) }
+
   describe "#authors" do
     it "should have a list of authors" do
       subject.should have(3).authors
     end
 
     describe "author" do
-      require "pp"
-      let(:author) { subject.authors.last }
+      let(:author) do
+        subject.authors.find do |author|
+          author.name.include?("Magnus Holm")
+        end
+      end
+
       it "should have a bunch of commits" do
-        author.raw_commits.should eq(23)
+        author.raw(:commits).should eq(41)
       end
 
       it "should respond to name" do
-        author.name.should eq("Linus Oleander")
+        author.name.should eq("Magnus Holm")
       end
 
       it "should have a number of locs" do
-        author.raw_loc.should eq(136)
+        author.raw(:loc).should eq(579)
       end
 
       it "should have a number of files" do
-        author.raw_files.should eq(7)
+        author.raw(:files).should eq(4)
       end
 
       it "should have a distribution" do
-        author.distribution.should eq("12.6 / 32.9 / 43.8")
+        author.distribution.should eq("53.9 / 58.6 / 25.0")
       end
     end
+
     describe "format" do
       let(:author) do
         GitFame::Author.new({
@@ -55,7 +61,7 @@ describe GitFame::Base do
     it "should respond to #loc, #commits and #files" do
       subject.files.should eq(16)
       subject.commits.should eq(70)
-      subject.loc.should eq(1082)
+      subject.loc.should eq(1075)
     end
   end
 
@@ -74,6 +80,7 @@ describe GitFame::Base do
         repository: repository,
         sort: "commits"
       }).authors
+
       authors.map(&:name).
         should eq(["Magnus Holm", "Linus Oleander", "7rans"])
     end
@@ -86,29 +93,55 @@ describe GitFame::Base do
       authors.map(&:name).
         should eq(["7rans", "Linus Oleander", "Magnus Holm"])
     end
+
+    it "should be able to sort #authors by loc" do
+      authors = GitFame::Base.new({
+        repository: repository,
+        sort: "loc"
+      }).authors
+      authors.map(&:name).
+        should eq(["Magnus Holm", "7rans", "Linus Oleander"])
+    end
   end
 
-  describe "#command_line_arguments" do
+  describe "exclude" do
     let(:subject) do
       GitFame::Base.new({
         repository: repository,
-        exclude: "lib",
-        bytype: true,
-        extensions: "rb,rdoc"
+        exclude: "lib/*"
       })
     end
 
     it "should exclude the lib folder" do
-      subject.file_list.include?("lib/gash.rb").should be_falsey
+      subject.file_list.map(&:path).should_not include("lib/gash.rb")
     end
 
     it "should exclude non rb or rdoc files" do
-      subject.file_list.include?("HISTORY").should be_falsey
+      subject.file_list.map(&:path).should include("HISTORY")
+    end
+
+    it "should exclude non matching paths" do
+      subject.file_list.map(&:path).should include("spec/gash_spec.rb")
+    end
+  end
+
+  describe "types" do
+    let(:subject) do
+      GitFame::Base.new({
+        repository: repository,
+        by_type: true,
+        extensions: "rb,rdoc"
+      })
+    end
+
+    let(:author) do 
+      subject.authors.find do |author| 
+        author.name == "7rans"
+      end
     end
 
-    let(:author) { subject.authors.find { |author| author.name == "7rans" } }
     it "should break out counts by file type" do
-      author.file_type_counts["rdoc"].should eq(23)
+      author.file_type_counts["rdoc"].should eq(1)
     end
 
     it "should output zero for file types the author hasn't touched" do
@@ -116,6 +149,43 @@ describe GitFame::Base do
     end
   end
 
+  describe "include" do
+    let(:subject) do
+      GitFame::Base.new({
+        repository: repository,
+        include: "lib/*,spec/*"
+      })
+    end
+
+    it "should exclude the lib folder" do
+      subject.file_list.map(&:path).should include("lib/gash.rb")
+    end
+
+    it "should exclude non rb or rdoc files" do
+      subject.file_list.map(&:path).should_not include("HISTORY")
+    end
+
+    it "should exclude non matching paths" do
+      subject.file_list.map(&:path).should include("spec/gash_spec.rb")
+    end
+  end
+
+  context "glob" do
+    it "should exclude" do
+      GitFame::Base.new({
+        repository: repository,
+        exclude: "lib/*.rb"
+      }).file_list.map(&:path).should_not include("lib/gash.rb")
+    end
+
+    it "should include" do
+      GitFame::Base.new({
+        repository: repository,
+        include: "lib/*.rb"
+      }).file_list.map(&:path).should include("lib/gash.rb")
+    end
+  end
+
   describe "#pretty_print" do
     it "should print" do
       lambda {
@@ -132,22 +202,21 @@ describe GitFame::Base do
     end
 
     it "should be equal to" do
-      subject.to_csv.should eq("name,loc,commits,files,distribution\n" \
-                            "Magnus Holm,586,41,4,54.2 / 58.6 / 25.0\n" \
-                            "7rans,360,6,10,33.3 /  8.6 / 62.5\n" \
-                            "Linus Oleander,136,23,7,12.6 / 32.9 / 43.8\n")
+      subject.to_csv.should eq([
+        "name,loc,commits,files,distribution\n",
+        "Magnus Holm,579,41,4,53.9 / 58.6 / 25.0\n",
+        "7rans,360,6,10,33.5 /  8.6 / 62.5\n",
+        "Linus Oleander,136,23,7,12.7 / 32.9 / 43.8\n",
+      ].join)
     end
   end
 
-  describe "branches" do
+  describe "branches", :this do
     it "should handle existing branches" do
-      authors = GitFame::Base.new({
+      GitFame::Base.new({
         repository: repository,
-        branch: "0.1.0"
+        branch: "master"
       }).authors
-
-      authors.count.should eq(1)
-      authors.first.name.should eq("Magnus Holm")
     end
 
     it "should raise an error if branch doesn't exist" do
@@ -156,7 +225,7 @@ describe GitFame::Base do
           repository: repository,
           branch: "-----"
         }).authors
-      }.to raise_error(GitFame::BranchNotFound)
+      }.to raise_error(GitFame::Error)
     end
 
     it "should not raise on empty branch (use fallback)" do
@@ -171,4 +240,225 @@ describe GitFame::Base do
       }).authors.should_not be_empty
     end
   end
+
+  describe "after", :this do
+    it "should raise error if 'after' is to far in the future" do
+      lambda do
+        GitFame::Base.new({
+          repository: repository,
+          after: "2020-01-01"
+        }).commits
+      end.should raise_error(GitFame::Error)
+    end
+
+    it "should handle same day as HEAD" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2012-05-23"
+      }).commits.should eq(1)
+    end
+
+    it "should handle an out of scope 'after' date" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2000-01-01"
+      }).commits.should eq(70)
+    end
+  end
+
+  describe "before", :this do
+    it "should raise error if 'before' is to far back in history" do
+      lambda do
+        GitFame::Base.new({
+          repository: repository,
+          before: "1972-01-01"
+        }).commits
+      end.should raise_error(GitFame::Error)
+    end
+
+    it "should handle same day as last commit" do
+      GitFame::Base.new({
+        repository: repository,
+        before: "2008-08-31"
+      }).commits.should eq(1)
+    end
+
+    it "should handle an out of scope 'before' date" do
+      GitFame::Base.new({
+        repository: repository,
+        before: "2050-01-01"
+      }).commits.should eq(70)
+    end
+
+    it "should handle same day as last commit" do
+      GitFame::Base.new({
+        repository: repository,
+        before: "2008-08-31"
+      }).commits.should eq(1)
+    end
+
+    it "should validate before date" do
+      lambda do
+        GitFame::Base.new({
+          repository: repository,
+          before: "----"
+        })
+      end.should raise_error(GitFame::Error)
+    end
+
+    it "should validate before date" do
+      lambda do
+        GitFame::Base.new({
+          repository: repository,
+          after: "----"
+        })
+      end.should raise_error(GitFame::Error)
+    end
+  end
+
+  describe "span", :this do
+    it "should handle spans as inclusive" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2008-09-01",
+        before: "2008-09-03"
+      }).commits.should eq(4)
+    end
+
+    it "should should possible a wide date span (include all)" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2000-01-01",
+        before: "2020-01-01"
+      }).commits.should eq(70)
+    end
+
+    it "should handle a too early 'after'" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2000-01-01",
+        before: "2008-08-31"
+      }).commits.should eq(1)
+    end
+
+    it "should catch empty commit span" do
+      lambda do
+        GitFame::Base.new({
+          repository: repository,
+          after: "2010-04-10",
+          before: "2010-04-11"
+        }).commits
+      end.should raise_error(GitFame::Error)
+    end
+
+    it "should handle a too late 'before'" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2012-02-29",
+        before: "2030-01-01"
+      }).commits.should eq(4)
+    end
+
+    it "should handle the after date same date as init commit" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2008-08-31",
+        before: "2008-09-03"
+      }).commits.should eq(5)
+    end
+
+    it "should handle an existing before with an old after" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2000-08-31",
+        before: "2008-09-03"
+      }).commits.should eq(5)
+    end
+
+    it "should handle an existing after with an old before" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2012-05-23",
+        before: "2020-01-01"
+      }).commits.should eq(1)
+    end
+
+    it "should raise an error if after > before" do
+      lambda do
+        GitFame::Base.new({
+          repository: repository,
+          after: "2020-01-01",
+          before: "2000-01-01"
+        }).commits
+      end.should raise_error(GitFame::Error)
+    end
+
+    it "should raise error if set too high" do
+      lambda do
+        GitFame::Base.new({
+          repository: repository,
+          after: "2030-01-01",
+          before: "2050-01-01"
+        }).commits
+      end.should raise_error(GitFame::Error)
+    end
+
+    it "should raise error if set too low" do
+      lambda do
+        GitFame::Base.new({
+          repository: repository,
+          after: "1990-01-01",
+          before: "2000-01-01"
+        }).commits
+      end.should raise_error(GitFame::Error)
+    end
+
+    it "should handle same day" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2012-02-29",
+        before: "2012-02-29"
+      }).commits.should eq(3)
+    end
+
+    it "should handle same day (HEAD)" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2012-05-23",
+        before: "2012-05-23"
+      }).commits.should eq(1)
+    end
+
+    it "should handle same day (last commit)" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2008-08-31",
+        before: "2008-08-31"
+      }).commits.should eq(1)
+    end
+
+    it "should handle a non existent 'after' date" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2008-09-02",
+        before: "2008-09-04"
+      }).commits.should eq(4)
+    end
+
+    it "should handle a non existent 'before' date" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2008-09-04",
+        before: "2008-09-05"
+      }).commits.should eq(3)
+    end
+
+    it "should handle both non existent 'before' and 'after'" do
+      GitFame::Base.new({
+        repository: repository,
+        after: "2008-09-02",
+        before: "2008-09-05"
+      }).commits.should eq(4)
+    end
+  end
 end