metric_fu 4.4.1 → 4.4.2

data/lib/metric_fu/metrics/saikuro/saikuro.rb

@@ -1,6 +1,8 @@
+MetricFu.metrics_require   { 'saikuro/scratch_file'    }
+MetricFu.metrics_require   { 'saikuro/parsing_element' }
 module MetricFu
 
-  class Saikuro < Generator
+  class SaikuroGenerator < MetricFu::Generator
 
     def self.metric
       :saikuro
@@ -102,152 +104,9 @@ module MetricFu
     end
 
     def assemble_files
-      files = []
-      Dir.glob("#{metric_directory}/**/*.html").each do |path|
-        if Saikuro::SFile.is_valid_text_file?(path)
-          file = Saikuro::SFile.new(path)
-          if file
-            files << file
-          end
-        end
-      end
-      files
+      SaikuroScratchFile.assemble_files( Dir.glob("#{metric_directory}/**/*.html") )
     end
 
   end
 
-  class Saikuro::SFile
-
-    attr_reader :elements
-
-    def initialize(path)
-      @path = path
-      @file_handle = File.open(@path, "r")
-      @elements = []
-      get_elements
-    ensure
-      @file_handle.close if @file_handle
-    end
-
-    def self.is_valid_text_file?(path)
-      File.open(path, "r") do |f|
-        if f.eof? || !f.readline.match(/--/)
-          return false
-        else
-          return true
-        end
-      end
-    end
-
-    def filename
-      File.basename(@path, '_cyclo.html')
-    end
-
-    def filepath
-      File.dirname(@path)
-    end
-
-    def to_h
-      merge_classes
-      {:classes => @elements}
-    end
-
-    def get_elements
-      begin
-        while (line = @file_handle.readline) do
-          return [] if line.nil? || line !~ /\S/
-          element ||= nil
-          if line.match(/START/)
-            unless element.nil?
-              @elements << element
-              element = nil
-            end
-            line = @file_handle.readline
-            element = Saikuro::ParsingElement.new(line)
-          elsif line.match(/END/)
-            @elements << element if element
-            element = nil
-          else
-            element << line if element
-          end
-        end
-      rescue EOFError
-        nil
-      end
-    end
-
-
-    def merge_classes
-      new_elements = []
-      get_class_names.each do |target_class|
-        elements = @elements.find_all {|el| el.name == target_class }
-        complexity = 0
-        lines = 0
-        defns = []
-        elements.each do |el|
-          complexity += el.complexity.to_i
-          lines += el.lines.to_i
-          defns << el.defs
-        end
-
-        new_element = {:class_name => target_class,
-                       :complexity => complexity,
-                       :lines => lines,
-                       :methods => defns.flatten.map {|d| d.to_h}}
-        new_element[:methods] = new_element[:methods].
-                                sort_by {|x| x[:complexity] }.
-                                reverse
-
-        new_elements << new_element
-      end
-      @elements = new_elements if new_elements
-    end
-
-    def get_class_names
-      class_names = []
-      @elements.each do |element|
-        unless class_names.include?(element.name)
-          class_names << element.name
-        end
-      end
-      class_names
-    end
-
-  end
-
-  class Saikuro::ParsingElement
-    TYPE_REGEX=/Type:(.*) Name/
-    NAME_REGEX=/Name:(.*) Complexity/
-    COMPLEXITY_REGEX=/Complexity:(.*) Lines/
-    LINES_REGEX=/Lines:(.*)/
-
-    attr_reader :complexity, :lines, :defs, :element_type
-    attr_accessor :name
-
-    def initialize(line)
-      @line = line
-      @element_type = line.match(TYPE_REGEX)[1].strip
-      @name = line.match(NAME_REGEX)[1].strip
-      @complexity = line.match(COMPLEXITY_REGEX)[1].strip
-      @lines = line.match(LINES_REGEX)[1].strip
-      @defs = []
-    end
-
-    def <<(line)
-      @defs << Saikuro::ParsingElement.new(line)
-    end
-
-    def to_h
-      base = {:name => @name, :complexity => @complexity.to_i, :lines => @lines.to_i}
-      unless @defs.empty?
-        defs = @defs.map do |my_def|
-          my_def = my_def.to_h
-          my_def.delete(:defs)
-          my_def
-        end
-        base[:defs] = defs
-      end
-      return base
-    end
-  end
 end

data/lib/metric_fu/metrics/saikuro/scratch_file.rb

@@ -0,0 +1,114 @@
+MetricFu.metrics_require   { 'saikuro/parsing_element' }
+module MetricFu
+  class SaikuroScratchFile
+
+    def self.assemble_files(glob)
+      files = []
+      glob.each do |path|
+        if is_valid_text_file?(path)
+          file = new(path)
+          if file
+            files << file
+          end
+        end
+      end
+      files
+    end
+
+    attr_reader :elements
+
+    def initialize(path)
+      @path = path
+      @file_handle = File.open(@path, "r")
+      @elements = []
+      get_elements
+    ensure
+      @file_handle.close if @file_handle
+    end
+
+    def self.is_valid_text_file?(path)
+      File.open(path, "r") do |f|
+        if f.eof? || !f.readline.match(/--/)
+          return false
+        else
+          return true
+        end
+      end
+    end
+
+    def filename
+      File.basename(@path, '_cyclo.html')
+    end
+
+    def filepath
+      File.dirname(@path)
+    end
+
+    def to_h
+      merge_classes
+      {:classes => @elements}
+    end
+
+    def get_elements
+      begin
+        while (line = @file_handle.readline) do
+          return [] if line.nil? || line !~ /\S/
+          element ||= nil
+          if line.match(/START/)
+            unless element.nil?
+              @elements << element
+              element = nil
+            end
+            line = @file_handle.readline
+            element = MetricFu::SaikuroParsingElement.new(line)
+          elsif line.match(/END/)
+            @elements << element if element
+            element = nil
+          else
+            element << line if element
+          end
+        end
+      rescue EOFError
+        nil
+      end
+    end
+
+
+    def merge_classes
+      new_elements = []
+      get_class_names.each do |target_class|
+        elements = @elements.find_all {|el| el.name == target_class }
+        complexity = 0
+        lines = 0
+        defns = []
+        elements.each do |el|
+          complexity += el.complexity.to_i
+          lines += el.lines.to_i
+          defns << el.defs
+        end
+
+        new_element = {:class_name => target_class,
+                       :complexity => complexity,
+                       :lines => lines,
+                       :methods => defns.flatten.map {|d| d.to_h}}
+        new_element[:methods] = new_element[:methods].
+                                sort_by {|x| x[:complexity] }.
+                                reverse
+
+        new_elements << new_element
+      end
+      @elements = new_elements if new_elements
+    end
+
+    def get_class_names
+      class_names = []
+      @elements.each do |element|
+        unless class_names.include?(element.name)
+          class_names << element.name
+        end
+      end
+      class_names
+    end
+
+  end
+end

data/lib/metric_fu/version.rb

@@ -1,3 +1,3 @@
 module MetricFu
-  VERSION = "4.4.1"
+  VERSION = "4.4.2"
 end

data/spec/metric_fu/configuration_spec.rb

@@ -225,13 +225,6 @@ describe MetricFu::Configuration do
         end
       end
 
-      describe '#set_code_dirs ' do
-        it 'should set the @code_dirs instance var to ["app", "lib"]' do
-          directory('code_dirs').
-                  should == ['app','lib']
-        end
-      end
-
       it 'should set @rails_best_practices to {}' do
         load_metric 'rails_best_practices'
         expect(MetricFu::Metric.get_metric(:rails_best_practices).run_options).to eql({})

data/spec/metric_fu/formatter/html_spec.rb

@@ -1,5 +1,4 @@
 require "spec_helper"
-require 'fakefs/safe'
 
 describe MetricFu::Formatter::HTML do
 

data/spec/metric_fu/formatter/yaml_spec.rb

@@ -1,5 +1,4 @@
 require "spec_helper"
-require 'fakefs/safe'
 
 describe MetricFu::Formatter::YAML do
 

data/spec/metric_fu/metrics/base_template_spec.rb

@@ -10,11 +10,10 @@ describe MetricFu::Template do
   describe "#erbify" do
     it 'should evaluate a erb doc' do
       section = 'section'
-      File.stub(:read).and_return('foo')
       erb = double('erb')
       erb.should_receive(:result)
-      ERB.should_receive(:new).with('foo').and_return(erb)
       @template.should_receive(:template).and_return('foo')
+      @template.should_receive(:erb_template_source).with('foo').and_return(erb)
       @template.send(:erbify, section)
     end
   end

data/spec/metric_fu/metrics/hotspots/analysis/analyzed_problems_spec.rb

@@ -37,16 +37,14 @@ describe MetricFu::HotspotAnalyzedProblems do
         :flog => "complexity is 37.9"
       }
       # TODO Unsure if we want to make problems_with and location public or private at this point
-      @analyzed_problems.method(:problems_with).call(:class, "Client").should == expected
-      expect(@worst_items[:classes].first[:details]).to eq(expected)
+      expect(@worst_items[:classes].first.problems).to eq(expected)
     end
 
     it "gives all issues for a method" do
       expected = {
         :reek => "found 1 code smells",
         :flog => "complexity is 37.9"}
-      @analyzed_problems.method(:problems_with).call(:method, "Client#client_requested_sync").should == expected
-      expect(@worst_items[:methods].first[:details]).to eq(expected)
+      expect(@worst_items[:methods].first.problems).to eq(expected)
     end
 
     it "gives all issues for a file" do
@@ -54,32 +52,28 @@ describe MetricFu::HotspotAnalyzedProblems do
         :reek => "found 2 code smells" ,
         :flog => "complexity is 37.9",
         :churn => "detected high level of churn (changed 54 times)"}
-      @analyzed_problems.method(:problems_with).call(:file, "lib/client/client.rb").should == expected
-      expect(@worst_items[:files].first[:details]).to eq(expected)
+      expect(@worst_items[:files].first.problems).to eq(expected)
     end
 
     it "provide location for a method" do
       expected = MetricFu::Location.new("lib/client/client.rb",
                               "Client",
                               "Client#client_requested_sync")
-      @analyzed_problems.method(:location).call(:method, "Client#client_requested_sync").should == expected
-      expect(@worst_items[:methods].first[:location]).to eq(expected)
+      expect(@worst_items[:methods].first.location).to eq(expected)
     end
 
     it "provides location for a class" do
       expected = MetricFu::Location.new("lib/client/client.rb",
                               "Client",
                               nil)
-      @analyzed_problems.method(:location).call(:class, "Client").should == expected
-      expect(@worst_items[:classes].first[:location]).to eq(expected)
+      expect(@worst_items[:classes].first.location).to eq(expected)
     end
 
     it "provides location for a file" do
       expected = MetricFu::Location.new("lib/client/client.rb",
                               nil,
                               nil)
-      @analyzed_problems.method(:location).call(:file, "lib/client/client.rb").should == expected
-      expect(@worst_items[:files].first[:location]).to eq(expected)
+      expect(@worst_items[:files].first.location).to eq(expected)
     end
 
   end
@@ -96,16 +90,14 @@ describe MetricFu::HotspotAnalyzedProblems do
       expected = {
         :saikuro => "complexity is 1.0"
       }
-      @analyzed_problems.method(:problems_with).call(:method, "Supr#initialize").should == expected
-      expect(@worst_items[:methods].last[:details]).to eq(expected)
+      expect(@worst_items[:methods].last.problems).to eq(expected)
     end
 
     it "gives average complexity for class" do
       expected = {
         :saikuro => "average complexity is 5.0"
       }
-      @analyzed_problems.method(:problems_with).call(:class, "Supr").should == expected
-      expect(@worst_items[:classes].last[:details]).to eq(expected)
+      expect(@worst_items[:classes].last.problems).to eq(expected)
     end
 
   end

data/spec/metric_fu/metrics/hotspots/hotspots_spec.rb

@@ -1,4 +1,3 @@
-require 'multi_json'
 require "spec_helper"
 
 describe MetricFu::HotspotsGenerator do
@@ -7,90 +6,48 @@ describe MetricFu::HotspotsGenerator do
     before :each do
       MetricFu::Configuration.run {}
       File.stub(:directory?).and_return(true)
-      @yaml =<<END
---- 
-:reek: 
-  :matches: 
-  - :file_path: lib/client/client.rb
-    :code_smells: 
-    - :type: Large Class
-      :message: has at least 27 methods
-      :method: Devver::Client
-    - :type: Long Method
-      :message: has approx 6 statements
-      :method: Devver::Client#client_requested_sync
-:flog: 
-  :method_containers: 
-  - :highest_score: 61.5870319141946
-    :path: /lib/client/client.rb
-    :methods: 
-      Client#client_requested_sync: 
-        :path: /lib/client/client.rb
-        :score: 37.9270319141946
-        :operators: 
-          :+: 1.70000000000001
-          :/: 1.80000000000001
-          :method_at_line: 1.90000000000001
-          :puts: 1.70000000000001
-          :assignment: 33.0000000000001
-          :in_method?: 1.70000000000001
-          :message: 1.70000000000001
-          :branch: 12.6
-          :<<: 3.40000000000001
-          :each: 1.50000000000001
-          :lit_fixnum: 1.45
-          :raise: 1.80000000000001
-          :each_pair: 1.3
-          :*: 1.60000000000001
-          :to_f: 2.00000000000001
-          :each_with_index: 3.00000000000001
-          :[]: 22.3000000000001
-          :new: 1.60000000000001
-    :average_score: 11.1209009055421
-    :total_score: 1817.6
-    :name: Client#client_requested_sync
-:churn: 
-  :changes: 
-  - :file_path: lib/client/client.rb
-    :times_changed: 54
-  - :file_path: lib/client/foo.rb
-    :times_changed: 52
-END
+      @yaml = metric_data('hotspots/generator.yml')
     end
 
     it "should be empty on error" do
       hotspots = MetricFu::HotspotsGenerator.new
       hotspots.instance_variable_set(:@analyzer, nil)
       result = hotspots.analyze
-      result.should == {}
-    end
-
-    it "should return yaml results" do
-      hotspots = MetricFu::HotspotsGenerator.new
-      analyzer = HotspotAnalyzer.new(@yaml)
-      hotspots.instance_variable_set(:@analyzer, analyzer)
-      result = hotspots.analyze
-      expected = MultiJson.load("{\"methods\":[{\"location\":{\"class_name\":\"Client\",\"method_name\":\"Client#client_requested_sync\",\"file_path\":\"lib/client/client.rb\",\"hash\":7919384682,\"simple_method_name\":\"#client_requested_sync\"},\"details\":{\"reek\":\"found 1 code smells\",\"flog\":\"complexity is 37.9\"}}],\"classes\":[{\"location\":{\"class_name\":\"Client\",\"method_name\":null,\"file_path\":\"lib/client/client.rb\",\"hash\":7995629750},\"details\":{\"reek\":\"found 2 code smells\",\"flog\":\"complexity is 37.9\"}}],\"files\":[{\"location\":{\"class_name\":null,\"method_name\":null,\"file_path\":\"lib/client/client.rb\",\"hash\":-5738801681},\"details\":{\"reek\":\"found 2 code smells\",\"flog\":\"complexity is 37.9\",\"churn\":\"detected high level of churn (changed 54 times)\"}},{\"location\":{\"class_name\":null,\"method_name\":null,\"file_path\":\"lib/client/foo.rb\",\"hash\":-7081271905},\"details\":{\"churn\":\"detected high level of churn (changed 52 times)\"}}]}")
-      compare_hashes(MultiJson.load(MultiJson.dump(hotspots.to_h[:hotspots])), expected)
+      result.should == {:files => [], :classes => [], :methods => []}
     end
 
     it "should put the changes into a hash" do
+      MetricFu.result.should_receive(:result_hash).and_return(@yaml)
       hotspots = MetricFu::HotspotsGenerator.new
-      analyzer = HotspotAnalyzer.new(@yaml)
-      hotspots.instance_variable_set(:@analyzer, analyzer)
       hotspots.analyze
-      expected =  MultiJson.load("{\"methods\":[{\"location\":{\"class_name\":\"Client\",\"method_name\":\"Client#client_requested_sync\",\"file_path\":\"lib/client/client.rb\",\"hash\":7919384682,\"simple_method_name\":\"#client_requested_sync\"},\"details\":{\"reek\":\"found 1 code smells\",\"flog\":\"complexity is 37.9\"}}],\"classes\":[{\"location\":{\"class_name\":\"Client\",\"method_name\":null,\"file_path\":\"lib/client/client.rb\",\"hash\":7995629750},\"details\":{\"reek\":\"found 2 code smells\",\"flog\":\"complexity is 37.9\"}}],\"files\":[{\"location\":{\"class_name\":null,\"method_name\":null,\"file_path\":\"lib/client/client.rb\",\"hash\":-5738801681},\"details\":{\"reek\":\"found 2 code smells\",\"flog\":\"complexity is 37.9\",\"churn\":\"detected high level of churn (changed 54 times)\"}},{\"location\":{\"class_name\":null,\"method_name\":null,\"file_path\":\"lib/client/foo.rb\",\"hash\":-7081271905},\"details\":{\"churn\":\"detected high level of churn (changed 52 times)\"}}]}")
-      compare_hashes(MultiJson.load(MultiJson.dump(hotspots.to_h[:hotspots])), expected)
+      result = hotspots.to_h[:hotspots]
+      expected = metric_data('hotspots/generator_analysis.yml')
+      # ensure expected granularities
+      expect(result.keys).to eq(expected.keys)
+
+      # for each granularity's location details
+      result.each do |granularity,location_details|
+        # map 2d array for this granularity of [details, location]
+        expected_result = expected.fetch(granularity).map {|ld| [ld.fetch('details'), ld.fetch('location')] }
+        # verify all the location details for this granularity match elements of expected_result
+        location_details.each do |location_detail|
+          location = location_detail.fetch('location')
+          details  = location_detail.fetch('details')
+          # get the location_detail array where the  where the locations (second element) match
+          expected_location_details = expected_result.rassoc(location)
+          # get the details (first element) from the expected location_details array
+          expected_details = expected_location_details[0]
+          expect(details).to eq(expected_details)
+        end
+      end
     end
+
     # really testing the output of analyzed_problems#worst_items
     it "should return the worst item granularities: files, classes, methods" do
       hotspots = MetricFu::HotspotsGenerator.new
       analyzer = HotspotAnalyzer.new(@yaml)
-      hotspots.instance_variable_set(:@analyzer, analyzer)
-      hotspots.analyze.keys.should =~ [:files, :classes, :methods]
+      expect(hotspots.analyze.keys).to eq([:files, :classes, :methods])
     end
   end
-end
-def compare_hashes(got,expected)
-  got.hash == expected.hash
+
 end