turbulence 1.2.3 → 1.3.0

data/spec/turbulence/cli_parser_spec.rb

@@ -0,0 +1,50 @@
+require 'rspec'
+require 'turbulence'
+
+describe Turbulence::CommandLineInterface::ConfigParser do
+  let(:config) { Turbulence::Configuration.new }
+
+  def parse(argv)
+    described_class.parse_argv_into_config(argv, config)
+  end
+
+  it "sets directory" do
+    parse %w( path/to/compute )
+    expect(config.directory).to eq 'path/to/compute'
+  end
+
+  it "sets SCM name to 'Perforce'" do
+    parse %w( --scm p4 )
+    expect(config.scm_name).to eq 'Perforce'
+  end
+
+  it "sets commit range" do
+    parse %w( --churn-range f3e1d7a6..830b9d3d9f )
+    expect(config.commit_range).to eq 'f3e1d7a6..830b9d3d9f'
+  end
+
+  it "sets compute mean" do
+    parse %w( --churn-mean )
+    expect(config.compute_mean).to be true
+  end
+
+  it "sets the exclusion pattern" do
+    parse %w( --exclude turbulence )
+    expect(config.exclusion_pattern).to eq 'turbulence'
+  end
+
+  it "sets the graph type" do
+    parse %w( --treemap )
+    expect(config.graph_type).to eq 'treemap'
+  end
+
+  it "sets no_open" do
+    parse %w( --no-open )
+    expect(config.no_open).to be true
+  end
+
+  it "sets output_dir" do
+    parse %w( --output spec/reports/turbulence )
+    expect(config.output_dir).to eq 'spec/reports/turbulence'
+  end
+end

data/spec/turbulence/command_line_interface_spec.rb

@@ -3,48 +3,63 @@ require 'turbulence'
 
 describe Turbulence::CommandLineInterface do
   let(:cli) { Turbulence::CommandLineInterface.new(%w(.), :output => nil) }
+
   describe "::TEMPLATE_FILES" do
     Turbulence::CommandLineInterface::TEMPLATE_FILES.each do |template_file|
-      File.dirname(template_file).should == Turbulence::CommandLineInterface::TURBULENCE_TEMPLATE_PATH
+      it "has #{File.basename(template_file)} in the template path" do
+        expect(File.dirname(template_file)).to eq Turbulence::CommandLineInterface::TURBULENCE_TEMPLATE_PATH
+      end
     end
   end
+
   describe "#generate_bundle" do
     before do
       FileUtils.remove_dir("turbulence", true)
     end
     it "bundles the files" do
       cli.generate_bundle
-      Dir.glob('turbulence/*').sort.should eq(["turbulence/cc.js",
-                                               "turbulence/highcharts.js",
-                                               "turbulence/jquery.min.js",
-                                               "turbulence/treemap.html",
-                                               "turbulence/turbulence.html"])
+      expect(Dir.glob('turbulence/*').sort).to eq(["turbulence/cc.js",
+                                                   "turbulence/highcharts.js",
+                                                   "turbulence/jquery.min.js",
+                                                   "turbulence/treemap.html",
+                                                   "turbulence/turbulence.html"])
     end
 
     it "passes along exclusion pattern" do
       cli = Turbulence::CommandLineInterface.new(%w(--exclude turbulence), :output => nil)
       cli.generate_bundle
       lines = File.new('turbulence/cc.js').readlines
-      lines.any? { |l| l =~ /turbulence\.rb/ }.should be_false
+      expect(lines.any? { |l| l =~ /turbulence\.rb/ }).to be false
+    end
+
+    it "outputs to custom directory when --output is specified" do
+      custom_dir = 'tmp/custom_output'
+      FileUtils.remove_dir(custom_dir, true)
+      cli = Turbulence::CommandLineInterface.new(['--output', custom_dir], :output => nil)
+      cli.generate_bundle
+      expect(Dir.glob("#{custom_dir}/*").sort).to eq(["#{custom_dir}/cc.js",
+                                                       "#{custom_dir}/highcharts.js",
+                                                       "#{custom_dir}/jquery.min.js",
+                                                       "#{custom_dir}/treemap.html",
+                                                       "#{custom_dir}/turbulence.html"])
+      FileUtils.remove_dir(custom_dir, true)
     end
   end
-  describe "command line options" do
-    let(:cli_churn_range) { Turbulence::CommandLineInterface.new(%w(--churn-range f3e1d7a6..830b9d3d9f path/to/compute)) }
-    let(:cli_churn_mean) { Turbulence::CommandLineInterface.new(%w(--churn-mean .)) }
-    let(:cli_exclusion_pattern) { Turbulence::CommandLineInterface.new(%w(--exclude turbulence)) }
 
-    it "sets churn range" do
-      cli_churn_range.directory.should == 'path/to/compute'
-      Turbulence::Calculators::Churn.commit_range.should == 'f3e1d7a6..830b9d3d9f'
+  describe "#output_path" do
+    before do
+      # Reset the singleton config between tests
+      Turbulence.instance_variable_set(:@config, nil)
     end
 
-    it "sets churn mean" do
-      cli_churn_mean.directory.should == '.'
-      Turbulence::Calculators::Churn.compute_mean.should be_true
+    it "defaults to ./turbulence when output_dir is not set" do
+      cli = Turbulence::CommandLineInterface.new(%w(.), :output => nil)
+      expect(cli.output_path).to eq(File.join(Dir.pwd, "turbulence"))
     end
 
-    it "sets the exclusion pattern" do
-      cli_exclusion_pattern.exclusion_pattern.should == 'turbulence'
+    it "returns the custom output_dir when set" do
+      cli = Turbulence::CommandLineInterface.new(%w(--output custom/path), :output => nil)
+      expect(cli.output_path).to eq('custom/path')
     end
   end
 end

data/spec/turbulence/configuration_spec.rb

@@ -0,0 +1,19 @@
+require 'rspec'
+require 'rspec/its'
+require 'turbulence'
+
+describe Turbulence::Configuration do
+  describe "defaults" do
+    its(:output)            { should eq(STDOUT) }
+    its(:directory)         { should eq(Dir.pwd) }
+    its(:graph_type)        { should eq('turbulence') }
+    its(:scm_name)          { should eq('Git') }
+    its(:scm)               { should eq(Turbulence::Scm::Git) }
+    its(:no_open)           { should eq(false) }
+    its(:output_dir)        { should be_nil }
+    its(:commit_range)      { should be_nil }
+    its(:compute_mean)      { should be_nil }
+    its(:exclusion_pattern) { should be_nil }
+  end
+end
+

data/spec/turbulence/generators/scatter_plot_spec.rb

@@ -2,93 +2,98 @@ require 'turbulence'
 
 describe Turbulence::Generators::ScatterPlot do
   context "with both Metrics" do
-    it "generates JavaScript" do
+    it "generates JavaScript", :aggregate_failures do
       generator = Turbulence::Generators::ScatterPlot.new(
-        "foo.rb" => { Turbulence::Calculators::Churn      => 1,
-                      Turbulence::Calculators::Complexity => 2 }
+        "foo.rb" => { :churn      => 1,
+                      :complexity => 2 }
       )
 
-      generator.to_js.should =~ /var directorySeries/
-      generator.to_js.should =~ /\"filename\"\:\"foo.rb\"/
-      generator.to_js.should =~ /\"x\":1/
-      generator.to_js.should =~ /\"y\":2/
+      expect(generator.to_js).to match(/var directorySeries/)
+      expect(generator.to_js).to match(/\"filename\"\:\"foo.rb\"/)
+      expect(generator.to_js).to match(/\"x\":1/)
+      expect(generator.to_js).to match(/\"y\":2/)
     end
   end
 
   context "with a missing Metric" do
     it "generates JavaScript" do
       generator = Turbulence::Generators::ScatterPlot.new(
-        "foo.rb" => { Turbulence::Calculators::Churn => 1 }
+        "foo.rb" => { :churn => 1 }
       )
 
-      generator.to_js.should == 'var directorySeries = {};'
+      expect(generator.to_js).to eq 'var directorySeries = {};'
     end
   end
 
   describe "#clean_metrics_from_missing_data" do
-    let(:spg) {Turbulence::Generators::ScatterPlot.new({})}
+    let(:spg) { Turbulence::Generators::ScatterPlot.new({}) }
 
     it "removes entries with missing churn" do
-      spg.stub(:metrics_hash).and_return("foo.rb" => {
-        Turbulence::Calculators::Complexity => 88.3})
-        spg.clean_metrics_from_missing_data.should == {}
+      allow(spg).to receive(:metrics_hash).and_return("foo.rb" => { :complexity => 88.3 })
+      expect(spg.clean_metrics_from_missing_data).to eq({})
     end
 
     it "removes entries with missing complexity" do
-      spg.stub(:metrics_hash).and_return("foo.rb" => {
-        Turbulence::Calculators::Churn => 1})
-        spg.clean_metrics_from_missing_data.should == {}
+      allow(spg).to receive(:metrics_hash).and_return("foo.rb" => { :churn => 1 })
+      expect(spg.clean_metrics_from_missing_data).to eq({})
     end
 
     it "keeps entries with churn and complexity present" do
-      spg.stub(:metrics_hash).and_return("foo.rb" => {
-        Turbulence::Calculators::Churn => 1,
-        Turbulence::Calculators::Complexity => 88.3})
-        spg.clean_metrics_from_missing_data.should_not == {}
+      allow(spg).to receive(:metrics_hash).and_return("foo.rb" => {
+        :churn      => 1,
+        :complexity => 88.3,
+      })
+
+      expect(spg.clean_metrics_from_missing_data).not_to eq({})
     end
   end
 
   describe "#grouped_by_directory" do
-    let(:spg) {Turbulence::Generators::ScatterPlot.new("lib/foo/foo.rb" => {
-      Turbulence::Calculators::Churn => 1},
-      "lib/bar.rb" => {
-      Turbulence::Calculators::Churn => 2} )}
-
-      it "uses \".\" to denote flat hierarchy" do
-        spg.stub(:metrics_hash).and_return("foo.rb" => {
-          Turbulence::Calculators::Churn => 1
-        })
-        spg.grouped_by_directory.should == {"." => [["foo.rb", {Turbulence::Calculators::Churn => 1}]]}
-      end
-
-      it "takes full path into account" do
-        spg.grouped_by_directory.should == {"lib/foo" => [["lib/foo/foo.rb", {Turbulence::Calculators::Churn => 1}]],
-          "lib" => [["lib/bar.rb", {Turbulence::Calculators::Churn => 2}]]}
-      end
+    let(:spg) {
+      Turbulence::Generators::ScatterPlot.new(
+        "lib/foo/foo.rb" => { :churn => 1 },
+        "lib/bar.rb" => { :churn => 2 }
+      )
+    }
+
+    it "uses \".\" to denote flat hierarchy" do
+      allow(spg).to receive(:metrics_hash).and_return("foo.rb" => { :churn => 1 })
+      expect(spg.grouped_by_directory).to eq({ "." => [["foo.rb", { :churn => 1 }]] })
+    end
+
+    it "takes full path into account" do
+      expect(spg.grouped_by_directory).to eq({
+        "lib/foo" => [["lib/foo/foo.rb", { :churn => 1 }]],
+        "lib" => [["lib/bar.rb", { :churn => 2 }]]
+      })
+    end
   end
 
   describe "#file_metrics_for_directory" do
-    let(:spg) {Turbulence::Generators::ScatterPlot.new({})}
+    let(:spg) { Turbulence::Generators::ScatterPlot.new({}) }
+
     it "assigns :filename, :x, :y" do
-      spg.file_metrics_for_directory("lib/foo/foo.rb" => {
-        Turbulence::Calculators::Churn => 1,
-        Turbulence::Calculators::Complexity => 88.2}).should == [{:filename => "lib/foo/foo.rb",
-        :x => 1, :y => 88.2}]
+      result = spg.file_metrics_for_directory("lib/foo/foo.rb" => {
+        :churn      => 1,
+        :complexity => 88.2,
+      })
+      expect(result).to eq [{ :filename => "lib/foo/foo.rb", :x => 1, :y => 88.2 }]
     end
   end
 
   describe Turbulence::FileNameMangler do
     subject { Turbulence::FileNameMangler.new }
+
     it "anonymizes a string" do
-      subject.mangle_name("chad").should_not == "chad"
+      expect(subject.mangle_name("chad")).not_to eq "chad"
     end
 
     it "maintains standard directory names" do
-      subject.mangle_name("/app/controllers/chad.rb").should =~ %r{/app/controllers/1.rb}
+      expect(subject.mangle_name("/app/controllers/chad.rb")).to match(%r{/app/controllers/1.rb})
     end
 
     it "honors leading path separators" do
-      subject.mangle_name("/a/b/c.rb").should == "/1/2/3.rb"
+      expect(subject.mangle_name("/a/b/c.rb")).to eq "/1/2/3.rb"
     end
   end
 end

data/spec/turbulence/generators/treemap_spec.rb

@@ -2,24 +2,24 @@ require 'turbulence'
 
 describe Turbulence::Generators::TreeMap do
   context "with both Metrics" do
-    it "generates JavaScript" do
+    it "generates JavaScript", :aggregate_failures do
       generator = Turbulence::Generators::TreeMap.new(
-        "foo.rb" => { Turbulence::Calculators::Churn      => 1,
-                      Turbulence::Calculators::Complexity => 2 }
+        "foo.rb" => { :churn      => 1,
+                      :complexity => 2 }
       )
 
-      generator.build_js.should =~ /var treemap_data/
-      generator.build_js.should =~ /\'foo.rb\'/
+      expect(generator.build_js).to match(/var treemap_data/)
+      expect(generator.build_js).to match(/\'foo.rb\'/)
     end
   end
 
   context "with a missing Metric" do
     it "generates JavaScript" do
       generator = Turbulence::Generators::TreeMap.new(
-        "foo.rb" => { Turbulence::Calculators::Churn => 1 }
+        "foo.rb" => { :churn => 1 }
       )
 
-      generator.build_js.should == "var treemap_data = [['File', 'Parent', 'Churn (size)', 'Complexity (color)'],\n['Root', null, 0, 0],\n];"
+      expect(generator.build_js).to eq "var treemap_data = [['File', 'Parent', 'Churn (size)', 'Complexity (color)'],\n['Root', null, 0, 0],\n];"
     end
   end
 end

data/spec/turbulence/scm/git_spec.rb

@@ -5,25 +5,26 @@ require 'fileutils'
 describe Turbulence::Scm::Git do
   describe "::is_repo?" do
     before do
-      @tmp = Dir.mktmpdir(nil,'..')
+      # Create temp dir in system temp location (outside any git repo)
+      @tmp = Dir.mktmpdir('turbulence-test')
     end
     after do
-      FileUtils.rmdir(@tmp)
+      FileUtils.remove_entry(@tmp)
     end
     it "returns true for the working directory" do
-      Turbulence::Scm::Git.is_repo?(".").should == true
+      expect(Turbulence::Scm::Git.is_repo?(".")).to eq true
     end
     it "return false for a newly created tmp directory" do
-      Turbulence::Scm::Git.is_repo?(@tmp).should == false
+      expect(Turbulence::Scm::Git.is_repo?(@tmp)).to eq false
     end
   end
 
   describe "::log_command" do
     it "takes an optional argument specify to the range" do
-      expect{Turbulence::Scm::Git.log_command("d551e63f79a90430e560ea871f4e1e39e6e739bd  HEAD")}.to_not raise_error
+      expect { Turbulence::Scm::Git.log_command("d551e63f79a90430e560ea871f4e1e39e6e739bd  HEAD") }.to_not raise_error
     end
     it "lists insertions/deletions per file and change" do
-      Turbulence::Scm::Git.log_command.should match(/\d+\t\d+\t[A-z.]*/)
+      expect(Turbulence::Scm::Git.log_command).to match(/\d+\t\d+\t[A-z.]*/)
     end
   end
 end

data/spec/turbulence/scm/perforce_spec.rb

@@ -1,11 +1,10 @@
 require 'turbulence/scm/perforce'
-require 'rspec/mocks'
 
 describe Turbulence::Scm::Perforce do
-  let (:p4_scm) { Turbulence::Scm::Perforce }
+  let(:p4_scm) { Turbulence::Scm::Perforce }
 
   before do
-    p4_scm.stub(:p4_list_changes) do
+    allow(p4_scm).to receive(:p4_list_changes).and_return(
       "Change 62660 on 2005/11/28 by x@client 'CHANGED: adapted to DESCODE '
 Change 45616 on 2005/07/12 by x@client 'ADDED: trigger that builds and '
 Change 45615 on 2005/07/12 by x@client 'ADDED: for testing purposes '
@@ -13,9 +12,9 @@ Change 45614 on 2005/07/12 by x@client 'COSMETIC: updated header '
 Change 11250 on 2004/09/17 by x@client 'CHANGED: trigger now also allow'
 Change 9250 on 2004/08/20 by x@client 'BUGFIX: bug#1583 (People can so'
 Change 5560 on 2004/04/26 by x@client 'ADDED: The \"BRANCHED\" tag.'"
-    end
+    )
 
-    p4_scm.stub(:p4_describe_change).with("5560") do
+    allow(p4_scm).to receive(:p4_describe_change).with("5560").and_return(
       "Change 5560 by x@client on 2004/04/26 17:25:03
 
         ADDED: The \"BRANCHED\" tag.
@@ -38,105 +37,111 @@ changed 1 chunks 3 / 3 lines
 add 0 chunks 0 lines
 deleted 0 chunks 0 lines
 changed 1 chunks 3 / 1 lines"
-    end
+    )
   end
 
   describe "::is_repo?" do
     before :each do
-      ENV.stub(:[]).with("P4CLIENT").and_return(nil)
-      ENV.stub(:[]).with("PATH").and_return("")
+      allow(ENV).to receive(:[]).with("P4CLIENT").and_return(nil)
+      allow(ENV).to receive(:[]).with("PATH").and_return("")
     end
 
     it "returns true if P4CLIENT is set " do
-      ENV.stub(:[]).with("P4CLIENT").and_return("c-foo.bar")
+      allow(ENV).to receive(:[]).with("P4CLIENT").and_return("c-foo.bar")
 
-      Turbulence::Scm::Perforce.is_repo?(".").should be_true
+      expect(Turbulence::Scm::Perforce.is_repo?(".")).to be true
     end
 
-    it "returns false if P4CLIENT is empty"  do
-      Turbulence::Scm::Perforce.is_repo?(".").should be_false
+    it "returns false if P4CLIENT is empty" do
+      expect(Turbulence::Scm::Perforce.is_repo?(".")).to be false
     end
 
     it "returns false if p4 is not available" do
-      Turbulence::Scm::Perforce.is_repo?(".").should be_false
+      expect(Turbulence::Scm::Perforce.is_repo?(".")).to be false
     end
   end
 
   describe "::log_command" do
     before do
-      p4_scm.stub(:depot_to_local).with("//admin/scripts/triggers/enforce-submit-comment.py")\
+      allow(p4_scm).to receive(:depot_to_local)
+        .with("//admin/scripts/triggers/enforce-submit-comment.py")
         .and_return("triggers/enforce-submit-comments.py")
-      p4_scm.stub(:depot_to_local).with("//admin/scripts/triggers/check-consistency.py")\
+      allow(p4_scm).to receive(:depot_to_local)
+        .with("//admin/scripts/triggers/check-consistency.py")
         .and_return("triggers/check-consistency.py")
-      p4_scm.stub(:p4_list_changes) do
+      allow(p4_scm).to receive(:p4_list_changes).and_return(
         "Change 5560 on 2004/04/26 by x@client 'ADDED: The \"BRANCHED\" tag.'"
-      end
+      )
     end
 
     it "takes an optional argument to specify the range" do
-      expect{Turbulence::Scm::Perforce.log_command("@1,2")}.to_not raise_error
+      expect { Turbulence::Scm::Perforce.log_command("@1,2") }.to_not raise_error
     end
 
     it "lists insertions/deletions per file and change" do
-      Turbulence::Scm::Perforce.log_command().should match(/\d+\t\d+\t[A-z.]*/)
+      expect(Turbulence::Scm::Perforce.log_command()).to match(/\d+\t\d+\t[A-z.]*/)
     end
   end
 
   describe "::changes" do
     it "lists changenumbers from parsing 'p4 changes' output" do
-      p4_scm.changes.should =~ %w[62660 45616 45615 45614 11250 9250 5560]
+      expect(p4_scm.changes).to match_array(%w[62660 45616 45615 45614 11250 9250 5560])
     end
   end
 
   describe "::files_per_change" do
     before do
-      p4_scm.stub(:depot_to_local).with("//admin/scripts/triggers/enforce-submit-comment.py")\
+      allow(p4_scm).to receive(:depot_to_local)
+        .with("//admin/scripts/triggers/enforce-submit-comment.py")
         .and_return("triggers/enforce-submit-comments.py")
-      p4_scm.stub(:depot_to_local).with("//admin/scripts/triggers/check-consistency.py")\
+      allow(p4_scm).to receive(:depot_to_local)
+        .with("//admin/scripts/triggers/check-consistency.py")
         .and_return("triggers/check-consistency.py")
     end
 
     it "lists files with churn" do
-      p4_scm.files_per_change("5560").should  =~ [[4,"triggers/enforce-submit-comments.py"],
-        [1,"triggers/check-consistency.py"]]
+      expect(p4_scm.files_per_change("5560")).to match_array([
+        [4, "triggers/enforce-submit-comments.py"],
+        [1, "triggers/check-consistency.py"]
+      ])
     end
   end
 
   describe "::transform_for_output" do
     it "adds a 0 for deletions" do
-      p4_scm.transform_for_output([1,"triggers/check-consistency.py"]).should == "1\t0\ttriggers/check-consistency.py\n"
+      expect(p4_scm.transform_for_output([1, "triggers/check-consistency.py"])).to eq "1\t0\ttriggers/check-consistency.py\n"
     end
   end
 
   describe "::depot_to_local" do
     describe "on windows" do
       before do
-        p4_scm.stub(:extract_clientfile_from_fstat_of).and_return("D:/Perforce/admin/scripts/triggers/enforce-no-head-change.py")
-        FileUtils.stub(:pwd).and_return("D:/Perforce")
+        allow(p4_scm).to receive(:extract_clientfile_from_fstat_of)
+          .and_return("D:/Perforce/admin/scripts/triggers/enforce-no-head-change.py")
+        allow(FileUtils).to receive(:pwd).and_return("D:/Perforce")
       end
 
       it "converts depot-style paths to local paths using forward slashes" do
-        p4_scm.depot_to_local("//admin/scripts/triggers/enforce-no-head-change.py").should \
-          == "admin/scripts/triggers/enforce-no-head-change.py"
+        expect(p4_scm.depot_to_local("//admin/scripts/triggers/enforce-no-head-change.py")).to eq "admin/scripts/triggers/enforce-no-head-change.py"
       end
     end
 
     describe "on unix" do
       before do
-        p4_scm.stub(:extract_clientfile_from_fstat_of).and_return("/home/jhwist/admin/scripts/triggers/enforce-no-head-change.py")
-        FileUtils.stub(:pwd).and_return("/home/jhwist")
+        allow(p4_scm).to receive(:extract_clientfile_from_fstat_of)
+          .and_return("/home/jhwist/admin/scripts/triggers/enforce-no-head-change.py")
+        allow(FileUtils).to receive(:pwd).and_return("/home/jhwist")
       end
 
       it "converts depot-style paths to local paths using forward slashes" do
-        p4_scm.depot_to_local("//admin/scripts/triggers/enforce-no-head-change.py").should \
-          == "admin/scripts/triggers/enforce-no-head-change.py"
+        expect(p4_scm.depot_to_local("//admin/scripts/triggers/enforce-no-head-change.py")).to eq "admin/scripts/triggers/enforce-no-head-change.py"
       end
     end
   end
 
   describe "::extract_clientfile_from_fstat_of" do
     before do
-      p4_scm.stub(:p4_fstat) do
+      allow(p4_scm).to receive(:p4_fstat).and_return(
         "... depotFile //admin/scripts/triggers/enforce-no-head-change.py
 ... clientFile /home/jhwist/admin/scripts/triggers/enforce-no-head-change.py
 ... isMapped
@@ -147,24 +152,23 @@ changed 1 chunks 3 / 1 lines"
 ... headChange 211211
 ... headModTime 1214555028
 ... haveRev 5"
-      end
+      )
     end
 
-    it "uses clientFile field"  do
-      p4_scm.extract_clientfile_from_fstat_of("//admin/scripts/triggers/enforce-no-head-change.py").should ==
-        "/home/jhwist/admin/scripts/triggers/enforce-no-head-change.py"
+    it "uses clientFile field" do
+      expect(p4_scm.extract_clientfile_from_fstat_of("//admin/scripts/triggers/enforce-no-head-change.py")).to eq "/home/jhwist/admin/scripts/triggers/enforce-no-head-change.py"
     end
   end
 
   describe "::sum_of_changes" do
     it "sums up changes" do
       output = "add 1 chunks 1 lines\ndeleted 0 chunks 0 lines\nchanged 1 chunks 3 / 3 lines"
-      p4_scm.sum_of_changes(output).should == 4
+      expect(p4_scm.sum_of_changes(output)).to eq 4
     end
 
     it "ignores junk" do
       output = "add nothing, change nothing"
-      p4_scm.sum_of_changes(output).should == 0
+      expect(p4_scm.sum_of_changes(output)).to eq 0
     end
   end
 end

data/spec/turbulence/turbulence_spec.rb

@@ -2,14 +2,22 @@ require 'rspec'
 require 'turbulence'
 
 describe Turbulence do
+  subject(:turb) { Turbulence.new(config) }
+
+  let(:config) {
+    Turbulence::Configuration.new.tap do |config|
+      config.directory         = '.'
+      config.exclusion_pattern = nil
+      config.output            = nil
+    end
+  }
+
   it "finds files of interest" do
-    turb = Turbulence.new(".")
-    turb.exclusion_pattern.should be_nil
-    turb.files_of_interest.should include "lib/turbulence.rb"
+    expect(turb.files_of_interest).to include "lib/turbulence.rb"
   end
-  
-  it "filters out exluded files" do
-    turb = Turbulence.new(".", nil, 'turbulence')
-    turb.files_of_interest.should_not include "lib/turbulence.rb"
+
+  it "filters out excluded files" do
+    config.exclusion_pattern = 'turbulence'
+    expect(turb.files_of_interest).not_to include "lib/turbulence.rb"
   end
 end

data/turbulence.gemspec

@@ -1,4 +1,5 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
 $:.push File.expand_path("../lib", __FILE__)
 require "turbulence/version"
 
@@ -8,21 +9,24 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Chad Fowler", "Michael Feathers", "Corey Haines"]
   s.email       = ["chad@chadfowler.com", "mfeathers@obtiva.com", "coreyhaines@gmail.com"]
-  s.homepage    = "http://chadfowler.com"
-  s.add_dependency "flog", "~>4.1"
-  s.add_dependency "json", ">= 1.4.6"
+  s.homepage    = "https://github.com/chad/turbulence"
+  s.license     = "MIT"
+
+  s.add_dependency "flog", ">= 4.1"
+  s.add_dependency "json"
   s.add_dependency "launchy", ">= 2.0.0"
-  s.add_development_dependency 'rspec', '~> 2.14.0'
+  s.add_dependency "racc"  # Required by flog's ruby_parser, removed from stdlib in Ruby 3.3+
+
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'rspec-its'
   s.add_development_dependency 'rake'
 
   s.summary     = %q{Automates churn + flog scoring on a git repo for a Ruby project}
-  s.description = %q{Based on this http://www.stickyminds.com/sitewide.asp?Function=edetail&ObjectType=COL&ObjectId=16679&tth=DYN&tt=siteemail&iDyn=2}
-
-  s.rubyforge_project = "turbulence"
+  s.description = %q{Automates churn + flog scoring on a git repo for a Ruby project. Based on the article https://www.stickyminds.com/article/getting-empirical-about-refactoring}
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-  s.required_ruby_version = '>= 1.8.7'
+  s.required_ruby_version = '>= 3.0'
 end