metric_fu 4.11.3 → 4.11.4

data/spec/metric_fu/formatter/yaml_spec.rb

@@ -1,53 +1,47 @@
 require "spec_helper"
-MetricFu.formatter_require { 'yaml' }
+MetricFu.formatter_require { "yaml" }
 
 describe MetricFu::Formatter::YAML do
-
   before do
     setup_fs
 
     config = MetricFu.configuration
 
     if config.mri?
-       @metric1 = :cane
+      @metric1 = :cane
     else
-       @metric1 = :stats
-       config.templates_configuration do |c|
-         c.syntax_highlighting = false
-       end
+      @metric1 = :stats
+      config.templates_configuration do |c|
+        c.syntax_highlighting = false
+      end
     end
-    allow(MetricFu::Metric.get_metric(@metric1)).to receive(:run_external).and_return('')
+    allow(MetricFu::Metric.get_metric(@metric1)).to receive(:run_external).and_return("")
     @metric2 = :hotspots
     MetricFu.result.add(@metric1)
     MetricFu.result.add(@metric2)
   end
 
   context "In general" do
-
     it "creates a report yaml file" do
       expect {
-      MetricFu::Formatter::YAML.new.finish
+        MetricFu::Formatter::YAML.new.finish
       }.to create_file("#{directory('base_directory')}/report.yml")
     end
-
   end
 
   context "given a custom output file" do
-
     before do
       @output = "customreport.yml"
     end
 
     it "creates a report yaml file to the custom output path" do
       expect {
-      MetricFu::Formatter::YAML.new(output: @output).finish
+        MetricFu::Formatter::YAML.new(output: @output).finish
       }.to create_file("#{directory('base_directory')}/customreport.yml")
     end
-
   end
 
   context "given a custom output stream" do
-
     before do
       @output = $stdout
     end
@@ -59,11 +53,9 @@ describe MetricFu::Formatter::YAML do
       expect(out).to include ":#{@metric1}:"
       expect(out).to include ":#{@metric2}:"
     end
-
   end
 
   after do
     cleanup_fs
   end
-
 end

data/spec/metric_fu/formatter_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe MetricFu::Formatter do
   describe "formatter class loading" do
     context "given a built-in formatter (string)" do
-      subject { MetricFu::Formatter.class_for('html') }
+      subject { MetricFu::Formatter.class_for("html") }
 
       it "returns the formatter class" do
         expect(subject).to eq(MetricFu::Formatter::HTML)
@@ -22,15 +22,15 @@ describe MetricFu::Formatter do
       subject { MetricFu::Formatter.class_for(:unknown) }
 
       it "raises an error" do
-        expect{ subject }.to raise_error(NameError)
+        expect { subject }.to raise_error(NameError)
       end
     end
 
     context "given a custom formatter that exists" do
-      subject { MetricFu::Formatter.class_for('MyCustomFormatter') }
+      subject { MetricFu::Formatter.class_for("MyCustomFormatter") }
 
       before do
-        stub_const('MyCustomFormatter', Class.new() { def initialize(*);end })
+        stub_const("MyCustomFormatter", Class.new { def initialize(*); end })
       end
 
       it "returns the formatter class" do
@@ -39,10 +39,10 @@ describe MetricFu::Formatter do
     end
 
     context "given a custom formatter that doesnt exist" do
-      subject { MetricFu::Formatter.class_for('MyNonExistentCustomFormatter') }
+      subject { MetricFu::Formatter.class_for("MyNonExistentCustomFormatter") }
 
       it "raises an error" do
-        expect{ subject }.to raise_error(NameError)
+        expect { subject }.to raise_error(NameError)
       end
     end
   end

data/spec/metric_fu/gem_version_spec.rb

@@ -1,14 +1,12 @@
-require 'spec_helper'
-MetricFu.lib_require { 'gem_version' }
+require "spec_helper"
+MetricFu.lib_require { "gem_version" }
 
 describe MetricFu::GemVersion do
-
   it "has a list of gem deps" do
     gem_version = MetricFu::GemVersion.new
     gem_deps = gem_version.gem_runtime_dependencies.map(&:name)
-    MetricFu::Metric.metrics.reject{|metric| metric.name == :hotspots || metric.name == :stats}.map(&:name).map(&:to_s).each do |metric_name|
+    MetricFu::Metric.metrics.reject { |metric| metric.name == :hotspots || metric.name == :stats }.map(&:name).map(&:to_s).each do |metric_name|
       expect(gem_deps).to include(metric_name)
     end
   end
-
 end

data/spec/metric_fu/generator_spec.rb

@@ -1,10 +1,8 @@
 require "spec_helper"
 
 describe MetricFu::Generator do
-
   include TestConstruct::Helpers
 
-
   class ConcreteClass < MetricFu::Generator
     def self.metric
       :concrete
@@ -21,7 +19,7 @@ describe MetricFu::Generator do
   end
 
   before(:each) do
-    ENV['CC_BUILD_ARTIFACTS'] = nil
+    ENV["CC_BUILD_ARTIFACTS"] = nil
     MetricFu.configuration.reset
     MetricFu.configure
     @concrete_class = ConcreteClass.new
@@ -29,39 +27,38 @@ describe MetricFu::Generator do
 
   describe "ConcreteClass#metric_directory" do
     it "should be '{artifact_dir}/scratch/concreteclass'" do
-      concrete_metric = double('concrete_metric')
+      concrete_metric = double("concrete_metric")
       expect(MetricFu::Metric).to receive(:get_metric).with(:concrete).and_return(concrete_metric)
       expect(concrete_metric).to receive(:run_options).and_return({})
-      compare_paths(ConcreteClass.metric_directory, scratch_directory('concrete'))
+      compare_paths(ConcreteClass.metric_directory, scratch_directory("concrete"))
     end
   end
 
   describe "#metric_directory" do
     it "should return the results of ConcreteClass#metric_directory" do
-      allow(ConcreteClass).to receive(:metric_directory).and_return('foo')
-      expect(@concrete_class.metric_directory).to eq('foo')
+      allow(ConcreteClass).to receive(:metric_directory).and_return("foo")
+      expect(@concrete_class.metric_directory).to eq("foo")
     end
   end
 
   describe "#generate_result" do
     it "should  raise an error when calling #emit" do
       @abstract_class = MetricFu::Generator.new
-      expect { @abstract_class.generate_result }.to  raise_error
+      expect { @abstract_class.generate_result }.to raise_error
     end
 
     it "should call #analyze" do
       @abstract_class = MetricFu::Generator.new
-      expect { @abstract_class.generate_result }.to  raise_error
+      expect { @abstract_class.generate_result }.to raise_error
     end
 
     it "should call #to_h" do
       @abstract_class = MetricFu::Generator.new
-      expect { @abstract_class.generate_result }.to  raise_error
+      expect { @abstract_class.generate_result }.to raise_error
     end
   end
 
   describe "#generate_result (in a concrete class)" do
-
     %w[emit analyze].each do |meth|
       it "should call ##{meth}" do
         expect(@concrete_class).to receive("#{meth}")
@@ -73,23 +70,20 @@ describe MetricFu::Generator do
       expect(@concrete_class).to receive(:to_h)
       @concrete_class.generate_result
     end
-
   end
 
   describe "path filter" do
-
     context "given a list of paths" do
-
       before do
         @paths = %w(lib/fake/fake.rb
-                  lib/this/dan_file.rb
-                  lib/this/ben_file.rb
-                  lib/this/avdi_file.rb
-                  basic.rb
-                  lib/bad/one.rb
-                  lib/bad/two.rb
-                  lib/bad/three.rb
-                  lib/worse/four.rb)
+                    lib/this/dan_file.rb
+                    lib/this/ben_file.rb
+                    lib/this/avdi_file.rb
+                    basic.rb
+                    lib/bad/one.rb
+                    lib/bad/two.rb
+                    lib/bad/three.rb
+                    lib/worse/four.rb)
         @container = create_construct
         @paths.each do |path|
           @container.file(path)
@@ -109,32 +103,28 @@ describe MetricFu::Generator do
       end
 
       it "should filter filename at root level" do
-        files = @concrete_class.remove_excluded_files(@paths, ['basic.rb'])
-        expect(files).not_to include('basic.rb')
+        files = @concrete_class.remove_excluded_files(@paths, ["basic.rb"])
+        expect(files).not_to include("basic.rb")
       end
 
       it "should remove files that are two levels deep" do
-        files = @concrete_class.remove_excluded_files(@paths, ['**/fake.rb'])
-        expect(files).not_to include('lib/fake/fake.rb')
+        files = @concrete_class.remove_excluded_files(@paths, ["**/fake.rb"])
+        expect(files).not_to include("lib/fake/fake.rb")
       end
 
       it "should remove files from an excluded directory" do
-        files = @concrete_class.remove_excluded_files(@paths, ['lib/bad/**'])
-        expect(files).not_to include('lib/bad/one.rb')
-        expect(files).not_to include('lib/bad/two.rb')
-        expect(files).not_to include('lib/bad/three.rb')
+        files = @concrete_class.remove_excluded_files(@paths, ["lib/bad/**"])
+        expect(files).not_to include("lib/bad/one.rb")
+        expect(files).not_to include("lib/bad/two.rb")
+        expect(files).not_to include("lib/bad/three.rb")
       end
 
       it "should support shell alternation globs" do
-        files = @concrete_class.remove_excluded_files(@paths, ['lib/this/{ben,dan}_file.rb'])
-        expect(files).not_to include('lib/this/dan_file.rb')
-        expect(files).not_to include('lib/this/ben_file.rb')
-        expect(files).to include('lib/this/avdi_file.rb')
+        files = @concrete_class.remove_excluded_files(@paths, ["lib/this/{ben,dan}_file.rb"])
+        expect(files).not_to include("lib/this/dan_file.rb")
+        expect(files).not_to include("lib/this/ben_file.rb")
+        expect(files).to include("lib/this/avdi_file.rb")
       end
-
     end
-
-
   end
-
 end

data/spec/metric_fu/loader_spec.rb

@@ -1,12 +1,10 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe MetricFu do
-
   it "loads the .metrics file" do
     # Global only for testing that this file gets loaded
     $metric_file_loaded = false
     MetricFu.loader.load_user_configuration
     expect($metric_file_loaded).to be_truthy
   end
-
 end

data/spec/metric_fu/metric_spec.rb

@@ -1,47 +1,43 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe MetricFu::Metric do
   before do
     @metric = MetricFu::Metric.get_metric(:flog)
-    #@original_options = @metric.run_options.dup
+    # @original_options = @metric.run_options.dup
   end
 
-  #it "can have its run_options over-written" do
-    #new_options = {:foo => 'bar'}
-    #@metric.run_options = new_options
-    #expect(@original_options).to_not eq(new_options)
-    #expect(@metric.run_options).to eq(new_options)
-  #end
+  # it "can have its run_options over-written" do
+  # new_options = {:foo => 'bar'}
+  # @metric.run_options = new_options
+  # expect(@original_options).to_not eq(new_options)
+  # expect(@metric.run_options).to eq(new_options)
+  # end
 
-  #it "can have its run_options modified" do
-    #new_options = {:foo => 'bar'}
-    #@metric.run_options.merge!(new_options)
-    #expect(@metric.run_options).to eq(@original_options.merge(new_options))
-  #end
+  # it "can have its run_options modified" do
+  # new_options = {:foo => 'bar'}
+  # @metric.run_options.merge!(new_options)
+  # expect(@metric.run_options).to eq(@original_options.merge(new_options))
+  # end
 
   context "given a valid configurable option" do
-
     before do
-      allow(@metric).to receive(:default_run_options).and_return({:foo => 'baz'})
+      allow(@metric).to receive(:default_run_options).and_return(foo: "baz")
     end
 
     it "can be configured as an attribute" do
-      @metric.foo = 'qux'
-      expect(@metric.run_options[:foo]).to eq('qux')
+      @metric.foo = "qux"
+      expect(@metric.run_options[:foo]).to eq("qux")
     end
-
   end
 
   context "given an invalid configurable option" do
-
     before do
       allow(@metric).to receive(:default_run_options).and_return({})
     end
 
     it "raises an error" do
-      expect { @metric.foo = 'bar' }.to raise_error(RuntimeError, /not a valid configuration option/)
+      expect { @metric.foo = "bar" }.to raise_error(RuntimeError, /not a valid configuration option/)
     end
-
   end
 
   after do

data/spec/metric_fu/metrics/cane/configuration_spec.rb

@@ -5,16 +5,16 @@ describe MetricFu::Configuration, "for cane" do
   it_behaves_like "configured" do
     if MetricFu.configuration.mri?
       it "should set @cane to " +
-                          %q(:dirs_to_cane => @code_dirs, :abc_max => 15, :line_length => 80, :no_doc => "n", :no_readme => "y") do
+        ':dirs_to_cane => @code_dirs, :abc_max => 15, :line_length => 80, :no_doc => "n", :no_readme => "y"' do
         load_metric "cane"
         expect(MetricFu::Metric.get_metric(:cane).run_options).to eq(
-          {
-            :dirs_to_cane => directory("code_dirs"),
-            :filetypes => ["rb"],
-            :abc_max => 15,
-            :line_length => 80,
-            :no_doc => "n",
-            :no_readme => "n"}
+
+            dirs_to_cane: directory("code_dirs"),
+            filetypes: ["rb"],
+            abc_max: 15,
+            line_length: 80,
+            no_doc: "n",
+            no_readme: "n"
             )
       end
     end

data/spec/metric_fu/metrics/cane/generator_spec.rb

@@ -1,9 +1,8 @@
-require 'spec_helper'
-MetricFu.metrics_require { 'cane/generator' }
+require "spec_helper"
+MetricFu.metrics_require { "cane/generator" }
 
 describe CaneGenerator do
   describe "emit method" do
-
     it "should execute cane command" do
       options = {}
       @cane = MetricFu::CaneGenerator.new(options)
@@ -12,42 +11,42 @@ describe CaneGenerator do
     end
 
     it "should use abc max option" do
-      options = {abc_max: 20}
+      options = { abc_max: 20 }
       @cane = MetricFu::CaneGenerator.new(options)
       expect(@cane).to receive(:run!).with(" --abc-max 20")
       output = @cane.emit
     end
 
     it "should use style max line length option" do
-      options = {line_length: 100}
+      options = { line_length: 100 }
       @cane = MetricFu::CaneGenerator.new(options)
       expect(@cane).to receive(:run!).with(" --style-measure 100")
       output = @cane.emit
     end
 
     it "should use no-doc if specified" do
-      options = {no_doc: 'y'}
+      options = { no_doc: "y" }
       @cane = MetricFu::CaneGenerator.new(options)
       expect(@cane).to receive(:run!).with(" --no-doc")
       output = @cane.emit
     end
 
     it "should include doc violations if no_doc != 'y'" do
-      options = {no_doc: 'n'}
+      options = { no_doc: "n" }
       @cane = MetricFu::CaneGenerator.new(options)
       expect(@cane).to receive(:run!).with("")
       output = @cane.emit
     end
 
     it "should use no-readme if specified" do
-      options = {no_readme: 'y'}
+      options = { no_readme: "y" }
       @cane = MetricFu::CaneGenerator.new(options)
       expect(@cane).to receive(:run!).with(" --no-readme")
       output = @cane.emit
     end
 
     it "should include README violations if no_readme != 'y'" do
-      options = {no_readme: 'n'}
+      options = { no_readme: "n" }
       @cane = MetricFu::CaneGenerator.new(options)
       expect(@cane).to receive(:run!).with("")
       output = @cane.emit
@@ -60,11 +59,10 @@ describe CaneGenerator do
       allow(File).to receive(:directory?).and_return(true)
       options = {}
       @cane = MetricFu::CaneGenerator.new(options)
-      @cane.instance_variable_set(:@output, '')
+      @cane.instance_variable_set(:@output, "")
     end
 
     describe "analyze method" do
-
       it "should find total violations" do
         @cane.analyze
         expect(@cane.total_violations).to eq(0)
@@ -77,12 +75,11 @@ describe CaneGenerator do
       lines = sample_cane_output
       MetricFu::Configuration.run {}
       allow(File).to receive(:directory?).and_return(true)
-      @cane = MetricFu::CaneGenerator.new('base_dir')
+      @cane = MetricFu::CaneGenerator.new("base_dir")
       @cane.instance_variable_set(:@output, lines)
     end
 
     describe "analyze method" do
-
       it "should find total violations" do
         @cane.analyze
         expect(@cane.total_violations).to eq(6)
@@ -91,39 +88,39 @@ describe CaneGenerator do
       it "should extract abc complexity violations" do
         @cane.analyze
         expect(@cane.violations[:abc_complexity]).to eq([
-          {file: 'lib/abc/foo.rb', method: 'Abc::Foo#method', complexity: '11'},
-          {file: 'lib/abc/bar.rb', method: 'Abc::Bar#method', complexity: '22'}
+          { file: "lib/abc/foo.rb", method: "Abc::Foo#method", complexity: "11" },
+          { file: "lib/abc/bar.rb", method: "Abc::Bar#method", complexity: "22" }
         ])
       end
 
       it "should extract line style violations" do
         @cane.analyze
         expect(@cane.violations[:line_style]).to eq([
-          {line: 'lib/line/foo.rb:1', description: 'Line is >80 characters (135)'},
-          {line: 'lib/line/bar.rb:2', description: 'Line contains trailing whitespace'}
+          { line: "lib/line/foo.rb:1", description: "Line is >80 characters (135)" },
+          { line: "lib/line/bar.rb:2", description: "Line contains trailing whitespace" }
         ])
       end
 
       it "should extract comment violations" do
         @cane.analyze
         expect(@cane.violations[:comment]).to eq([
-          {line: 'lib/comments/foo.rb:1', class_name: 'Foo'},
-          {line: 'lib/comments/bar.rb:2', class_name: 'Bar'}
+          { line: "lib/comments/foo.rb:1", class_name: "Foo" },
+          { line: "lib/comments/bar.rb:2", class_name: "Bar" }
         ])
       end
 
       it "should extract no readme violations if present" do
         @cane.analyze
         expect(@cane.violations[:documentation]).to eq([
-          {description: 'No README found'},
+          { description: "No README found" },
         ])
       end
 
       it "should extract unknown violations in others category" do
         @cane.analyze
         expect(@cane.violations[:others]).to eq([
-          {description: 'Misc issue 1'},
-          {description: 'Misc issue 2'}
+          { description: "Misc issue 1" },
+          { description: "Misc issue 2" }
         ])
       end
     end
@@ -134,19 +131,19 @@ describe CaneGenerator do
         expect(@cane.to_h[:cane][:total_violations]).to eq(6)
       end
 
-      it  "should have violations by category" do
+      it "should have violations by category" do
         @cane.analyze
         expect(@cane.to_h[:cane][:violations][:abc_complexity]).to eq([
-          {file: 'lib/abc/foo.rb', method: 'Abc::Foo#method', complexity: '11'},
-          {file: 'lib/abc/bar.rb', method: 'Abc::Bar#method', complexity: '22'}
+          { file: "lib/abc/foo.rb", method: "Abc::Foo#method", complexity: "11" },
+          { file: "lib/abc/bar.rb", method: "Abc::Bar#method", complexity: "22" }
         ])
         expect(@cane.to_h[:cane][:violations][:line_style]).to eq([
-          {line: 'lib/line/foo.rb:1', description: 'Line is >80 characters (135)'},
-          {line: 'lib/line/bar.rb:2', description: 'Line contains trailing whitespace'}
+          { line: "lib/line/foo.rb:1", description: "Line is >80 characters (135)" },
+          { line: "lib/line/bar.rb:2", description: "Line contains trailing whitespace" }
         ])
         expect(@cane.to_h[:cane][:violations][:comment]).to eq([
-          {line: 'lib/comments/foo.rb:1', class_name: 'Foo'},
-          {line: 'lib/comments/bar.rb:2', class_name: 'Bar'}
+          { line: "lib/comments/foo.rb:1", class_name: "Foo" },
+          { line: "lib/comments/bar.rb:2", class_name: "Bar" }
         ])
       end
     end