git_statistics 0.7.0 → 0.8.0

data/spec/formatters/console_spec.rb

@@ -3,174 +3,188 @@ include GitStatistics
 include GitStatistics::Formatters
 
 describe Console do
-  let(:limit) {100}
-  let(:fresh) {true}
-  let(:pretty) {false}
+  let(:limit) { 100 }
+  let(:fresh) { true }
+  let(:pretty) { false }
   let(:repo) { GIT_REPO }
-  let(:collector) {Collector.new(repo, limit, fresh, pretty)}
+  let(:collector) { Collector.new(repo, limit, fresh, pretty) }
 
-  let(:commits) {collector.commits}
+  let(:commits) { collector.commits }
 
-  let(:fixture_file) {"multiple_authors.json"}
-  let(:save_file) { File.join(collector.commits_path, "0.json") }
-  let(:email) {false}
-  let(:merge) {false}
-  let(:sort) {:commits}
-  let(:top_n) {0}
+  let(:fixture_file) { 'multiple_authors.json' }
+  let(:save_file) { File.join(collector.commits_path, '0.json') }
+  let(:email) { false }
+  let(:merge) { false }
+  let(:sort) { :commits }
+  let(:top_n) { 0 }
 
-  let(:results) {
+  let(:results) do
     setup_commits(commits, fixture_file, save_file, pretty)
     commits.calculate_statistics(email, merge)
     commits.author_top_n_type(sort)
-    results = Console.new(commits)
-  }
+    Console.new(commits)
+  end
 
-  let(:config) {
+  let(:config) do
     results.prepare_result_summary(sort, email, top_n)
-  }
+  end
 
   before { config }
 
-  describe "#prepare_result_summary" do
-    context "with email and sorting" do
-      context "on first author" do
-        let(:data) {config[:data]}
-        author = "Kevin Jalbert"
-        subject {data[author]}
-
-        it {data.should have_key author}
-
-        it {subject[:commits].should == 1}
-        it {subject[:additions].should == 73}
-        it {subject[:deletions].should == 0}
-        it {subject[:added_files].should == 2}
-
-        it {subject[:languages][:Ruby][:additions].should == 62}
-        it {subject[:languages][:Ruby][:deletions].should == 0}
-        it {subject[:languages][:Ruby][:added_files].should == 1}
-        it {subject[:languages][:Markdown][:additions].should == 11}
-        it {subject[:languages][:Markdown][:deletions].should == 0}
-        it {subject[:languages][:Markdown][:added_files].should == 1}
+  describe '#prepare_result_summary' do
+    context 'with email and sorting' do
+      context 'on first author' do
+        let(:data) { config[:data] }
+        author = 'Kevin Jalbert'
+        subject { data[author] }
+
+        it do
+          expect(data.key?(author)).to be true
+
+          expect(subject[:commits]).to eq(1)
+          expect(subject[:additions]).to eq(73)
+          expect(subject[:deletions]).to eq(0)
+          expect(subject[:added_files]).to eq(2)
+
+          expect(subject[:languages][:Ruby][:additions]).to eq(62)
+          expect(subject[:languages][:Ruby][:deletions]).to eq(0)
+          expect(subject[:languages][:Ruby][:added_files]).to eq(1)
+          expect(subject[:languages][:Markdown][:additions]).to eq(11)
+          expect(subject[:languages][:Markdown][:deletions]).to eq(0)
+          expect(subject[:languages][:Markdown][:added_files]).to eq(1)
+        end
       end
 
-      context "on second author" do
-        let(:data) {config[:data]}
-        author = "John Smith"
-        subject {data[author]}
+      context 'on second author' do
+        let(:data) { config[:data] }
+        author = 'John Smith'
+        subject { data[author] }
 
-        it {data.has_key?(author).should be_true}
-        it {subject[:commits].should == 1}
-        it {subject[:additions].should == 64}
-        it {subject[:deletions].should == 16}
+        it do
+          expect(data.key?(author)).to be true
+          expect(subject[:commits]).to eq(1)
+          expect(subject[:additions]).to eq(64)
+          expect(subject[:deletions]).to eq(16)
 
-        it {subject[:languages][:Ruby][:additions].should == 64}
-        it {subject[:languages][:Ruby][:deletions].should == 16}
+          expect(subject[:languages][:Ruby][:additions]).to eq(64)
+          expect(subject[:languages][:Ruby][:deletions]).to eq(16)
+        end
       end
 
-      it {config[:sort].should == sort}
-      it {config[:email].should == email}
-      it {config[:top_n].should == top_n}
-      it {config[:author_length].should == 17}
-      it {config[:language_length].should == 8}
+      it do
+        expect(config[:sort]).to eq(sort)
+        expect(config[:email]).to eq(email)
+        expect(config[:top_n]).to eq(top_n)
+        expect(config[:author_length]).to eq(17)
+        expect(config[:language_length]).to eq(8)
+      end
     end
 
-    context "with negative top_n" do
-      let(:top_n) {-1}
+    context 'with negative top_n' do
+      let(:top_n) { -1 }
+
+      context 'on first author' do
+        let(:data) { config[:data] }
+        author = 'Kevin Jalbert'
+        subject { data[author] }
+
+        it do
+          expect(data.key?(author)).to be true
+
+          expect(subject[:commits]).to eq(1)
+          expect(subject[:additions]).to eq(73)
+          expect(subject[:deletions]).to eq(0)
+          expect(subject[:added_files]).to eq(2)
+
+          expect(subject[:languages][:Ruby][:additions]).to eq(62)
+          expect(subject[:languages][:Ruby][:deletions]).to eq(0)
+          expect(subject[:languages][:Ruby][:added_files]).to eq(1)
+          expect(subject[:languages][:Markdown][:additions]).to eq(11)
+          expect(subject[:languages][:Markdown][:deletions]).to eq(0)
+          expect(subject[:languages][:Markdown][:added_files]).to eq(1)
+        end
+      end
 
-      context "on first author" do
-        let(:data) {config[:data]}
-        author = "Kevin Jalbert"
-        subject {data[author]}
+      context 'on second author' do
+        let(:data) { config[:data] }
+        author = 'John Smith'
+        subject { data[author] }
 
-        it {data.has_key?(author).should be_true}
+        it do
+          expect(data.key?(author)).to be true
 
-        it {subject[:commits].should == 1}
-        it {subject[:additions].should == 73}
-        it {subject[:deletions].should == 0}
-        it {subject[:added_files].should == 2}
+          expect(subject[:commits]).to eq(1)
+          expect(subject[:additions]).to eq(64)
+          expect(subject[:deletions]).to eq(16)
 
-        it {subject[:languages][:Ruby][:additions].should == 62}
-        it {subject[:languages][:Ruby][:deletions].should == 0}
-        it {subject[:languages][:Ruby][:added_files].should == 1}
-        it {subject[:languages][:Markdown][:additions].should == 11}
-        it {subject[:languages][:Markdown][:deletions].should == 0}
-        it {subject[:languages][:Markdown][:added_files].should == 1}
+          expect(subject[:languages][:Ruby][:additions]).to eq(64)
+          expect(subject[:languages][:Ruby][:deletions]).to eq(16)
+        end
       end
 
-      context "on second author" do
-        let(:data) {config[:data]}
-        author = "John Smith"
-        subject {data[author]}
-
-        it {data.has_key?(author).should be_true}
-        it {subject[:commits].should == 1}
-        it {subject[:additions].should == 64}
-        it {subject[:deletions].should == 16}
-
-        it {subject[:languages][:Ruby][:additions].should == 64}
-        it {subject[:languages][:Ruby][:deletions].should == 16}
+      it do
+        expect(config[:sort]).to eq(sort)
+        expect(config[:email]).to eq(email)
+        expect(config[:top_n]).to eq(0)
+        expect(config[:author_length]).to eq(17)
+        expect(config[:language_length]).to eq(8)
       end
-
-      it {config[:sort].should == sort}
-      it {config[:email].should == email}
-      it {config[:top_n].should == 0}
-      it {config[:author_length].should == 17}
-      it {config[:language_length].should == 8}
     end
 
-    context "with top_n that filters to one author" do
-      let(:top_n) {1}
-      let(:data) {config[:data]}
-      author = "Kevin Jalbert"
-      subject {data[author]}
-
-      it {data.has_key?(author).should be_true}
-
-      it {subject[:commits].should == 1}
-      it {subject[:additions].should == 73}
-      it {subject[:deletions].should == 0}
-      it {subject[:added_files].should == 2}
-
-      it {subject[:languages][:Ruby][:additions].should == 62}
-      it {subject[:languages][:Ruby][:deletions].should == 0}
-      it {subject[:languages][:Ruby][:added_files].should == 1}
-      it {subject[:languages][:Markdown][:additions].should == 11}
-      it {subject[:languages][:Markdown][:deletions].should == 0}
-      it {subject[:languages][:Markdown][:added_files].should == 1}
-
-      it {config[:sort].should == sort}
-      it {config[:email].should == email}
-      it {config[:top_n].should == top_n}
-      it {config[:author_length].should == 17}
-      it {config[:language_length].should == 8}
+    context 'with top_n that filters to one author' do
+      let(:top_n) { 1 }
+      let(:data) { config[:data] }
+      author = 'Kevin Jalbert'
+      subject { data[author] }
+
+      it do
+        expect(data.key?(author)).to be true
+
+        expect(subject[:commits]).to eq(1)
+        expect(subject[:additions]).to eq(73)
+        expect(subject[:deletions]).to eq(0)
+        expect(subject[:added_files]).to eq(2)
+
+        expect(subject[:languages][:Ruby][:additions]).to eq(62)
+        expect(subject[:languages][:Ruby][:deletions]).to eq(0)
+        expect(subject[:languages][:Ruby][:added_files]).to eq(1)
+        expect(subject[:languages][:Markdown][:additions]).to eq(11)
+        expect(subject[:languages][:Markdown][:deletions]).to eq(0)
+        expect(subject[:languages][:Markdown][:added_files]).to eq(1)
+
+        expect(config[:sort]).to eq(sort)
+        expect(config[:email]).to eq(email)
+        expect(config[:top_n]).to eq(top_n)
+        expect(config[:author_length]).to eq(17)
+        expect(config[:language_length]).to eq(8)
+      end
     end
   end
 
-  describe "output" do
+  describe 'output' do
     let(:output) { fixture(file).file.read }
-    describe "#print_summary" do
-      context "with valid data" do
-        let(:file) { "summary_output.txt" }
-        subject {results.print_summary(sort, email)}
-        it { should == output.chomp }
+    describe '#print_summary' do
+      context 'with valid data' do
+        let(:file) { 'summary_output.txt' }
+        subject { results.print_summary(sort, email) }
+        it { expect(subject).to eq(output.chomp) }
       end
     end
 
-    describe "#print_language_data" do
-      context "with valid data" do
-        let(:file) { "language_data_output.txt" }
-        subject {results.print_language_data(config[:data]["Kevin Jalbert"])}
-        it {should == output.split("\n")}
+    describe '#print_language_data' do
+      context 'with valid data' do
+        let(:file) { 'language_data_output.txt' }
+        subject { results.print_language_data(config[:data]['Kevin Jalbert']) }
+        it { expect(subject).to eq(output.split("\n")) }
       end
     end
 
-    describe "#print_header" do
-      context "with valid data" do
-        let(:file) { "header_output.txt" }
+    describe '#print_header' do
+      context 'with valid data' do
+        let(:file) { 'header_output.txt' }
         subject { results.print_header.join("\n") }
-        it {should == output.chomp}
+        it { expect(subject).to eq(output.chomp) }
       end
     end
   end
-
 end

data/spec/log_spec.rb

@@ -3,52 +3,50 @@ require 'spec_helper'
 include GitStatistics
 
 describe Log do
-
   let(:log) { Class.new(Log) }
 
-  context "initializes instance" do
-    it "should acts as singleton" do
-      log.instance.should == log.instance
+  context 'initializes instance' do
+    it 'acts as singleton' do
+      expect(log.instance).to eq(log.instance)
     end
 
-    it "should have a logger" do
-      log.instance.logger.should be_a Logger
+    it 'has a logger' do
+      expect(log.instance.logger).to be_a(Logger)
     end
 
-    it "should be a Log (FakeLog)" do
-      log.class.should eq Log.class
+    it 'is a Log (FakeLog)' do
+      expect(log.class).to eq(Log.class)
     end
 
-    it "should react to Logger methods" do
+    it 'reacts to Logger methods' do
       Logger.public_instance_methods.each do |method|
-        log.valid_method?(method).should be_true
+        expect(log.valid_method?(method)).to be true
       end
     end
   end
 
-  context "#use_debug" do
+  context '#use_debug' do
     it "logger's progname before" do
-      log.progname.should be_nil
+      expect(log.progname).to be nil
     end
 
     it "logger's progname after" do
       log.use_debug
-      log.progname.should_not be_nil
+      expect(log.progname).to_not be nil
     end
   end
 
-  context "#parse_caller" do
-    context "with nothing" do
-      it {log.parse_caller(nil).should be_nil}
+  context '#parse_caller' do
+    context 'with nothing' do
+      it { expect(log.parse_caller(nil)).to be nil }
     end
 
-    context "with jumble (random text)" do
-      it {log.parse_caller("asdaacsdc").should be_nil}
+    context 'with jumble (random text)' do
+      it { expect(log.parse_caller('asdaacsdc')).to be nil }
     end
 
-    context "with valid caller" do
-      it {log.parse_caller("git_statistics/lib/git_statistics/log.rb:45:in `respond_to_missing?'").should eq "git_statistics/lib/git_statistics/log.rb:45"}
+    context 'with valid caller' do
+      it { expect(log.parse_caller("git_statistics/lib/git_statistics/log.rb:45:in `respond_to_missing?'")).to eq('git_statistics/lib/git_statistics/log.rb:45') }
     end
   end
-
 end

data/spec/pipe_spec.rb

@@ -4,56 +4,61 @@ include GitStatistics
 
 describe Pipe do
   let(:command) { 'git' }
-  let(:line)    { "" }
+  let(:line)    { '' }
   let(:pipe)    { Pipe.new(command) }
 
-  context "initializes correctly" do
-    context "with pipe character" do
+  context 'initializes correctly' do
+    context 'with pipe character' do
       let(:command) { '|git log --oneline' }
-      it { expect(pipe.command).to eq 'git log --oneline'}
+      it { expect(pipe.command).to eq('git log --oneline') }
     end
-    context "without pipe character" do
+
+    context 'without pipe character' do
       let(:command) { 'stat something else' }
-      it { expect(pipe.command).to eq 'stat something else'}
+      it { expect(pipe.command).to eq('stat something else') }
     end
   end
 
-  context "#empty?" do
-    before { pipe.stub(:lines) { lines } }
-    context "with empty lines" do
+  context '#empty?' do
+    before { allow(pipe).to receive(:lines) { lines } }
+
+    context 'with empty lines' do
       let(:lines) { [] }
-      it { pipe.should be_empty }
+      it { expect(pipe).to be_empty }
     end
-    context "with a single line" do
-      let(:lines) { [stub] }
-      it { pipe.should_not be_empty }
+
+    context 'with a single line' do
+      let(:lines) { [double] }
+      it { expect(pipe).to_not be_empty }
     end
   end
 
-  context "#each" do
+  context '#each' do
     before do
-      pipe.stub(:lines) { [line, line] }
+      allow(pipe).to receive(:lines) { [line, line] }
     end
-    it "should delegate to the lines" do
-      line.should_receive(:call).twice
+
+    it 'should delegate to the lines' do
+      expect(line).to receive(:call).twice
       pipe.each(&:call)
     end
   end
 
-  context "#lines" do
+  context '#lines' do
     before do
-      line.should_receive(:strip).twice.and_call_original
-      pipe.stub(:io) { [line, line] }
+      expect(line).to receive(:strip).twice.and_return('')
+      allow(pipe).to receive(:io) { [line, line] }
     end
+
     it { pipe.lines }
   end
 
-  context "#io" do
-    it "should call #open and pass the command through" do
-      pipe.should_receive(:open).with(/\A|#{command}/)
+  context '#io' do
+    it 'should call #open and pass the command through' do
+      expect(pipe).to receive(:open).with(/\A|#{command}/)
       pipe.io
     end
-    it { pipe.io.should be_an IO }
-  end
 
+    it { expect(pipe.io).to be_an(IO) }
+  end
 end