metric_fu 2.1.3.4 → 2.1.3.5

data/lib/errors/analysis_error.rb

@@ -1 +1,4 @@
-class AnalysisError < RuntimeError; end;
+module MetricFu
+  class AnalysisError < RuntimeError
+  end
+end

data/lib/metrics/churn/{churn_analyzer.rb → churn_hotspot.rb}

@@ -1,5 +1,5 @@
-class ChurnAnalyzer
-  include ScoringStrategies
+class ChurnHotspot
+  include MetricFu::HotspotScoringStrategies
 
   COLUMNS = %w{times_changed}
 
@@ -12,11 +12,11 @@ class ChurnAnalyzer
   end
 
   def map(row)
-    ScoringStrategies.present(row)
+    MetricFu::HotspotScoringStrategies.present(row)
   end
 
   def reduce(scores)
-    ScoringStrategies.sum(scores)
+    MetricFu::HotspotScoringStrategies.sum(scores)
   end
 
   def score(metric_ranking, item)

data/lib/metrics/flay/{flay_analyzer.rb → flay_hotspot.rb}

@@ -1,5 +1,5 @@
-class FlayAnalyzer
-  include ScoringStrategies
+class FlayHotspot
+  include MetricFu::HotspotScoringStrategies
 
   COLUMNS = %w{flay_reason flay_matching_reason}
 
@@ -12,15 +12,15 @@ class FlayAnalyzer
   end
 
   def map(row)
-    ScoringStrategies.present(row)
+    MetricFu::HotspotScoringStrategies.present(row)
   end
 
   def reduce(scores)
-    ScoringStrategies.sum(scores)
+    MetricFu::HotspotScoringStrategies.sum(scores)
   end
 
   def score(metric_ranking, item)
-    ScoringStrategies.percentile(metric_ranking, item)
+    MetricFu::HotspotScoringStrategies.percentile(metric_ranking, item)
   end
 
   def generate_records(data, table)

data/lib/metrics/flog/{flog_analyzer.rb → flog_hotspot.rb}

@@ -1,5 +1,5 @@
-class FlogAnalyzer
-  include ScoringStrategies
+class FlogHotspot
+  include MetricFu::HotspotScoringStrategies
 
   COLUMNS = %w{score}
 
@@ -16,11 +16,11 @@ class FlogAnalyzer
   end
 
   def reduce(scores)
-    ScoringStrategies.average(scores)
+    MetricFu::HotspotScoringStrategies.average(scores)
   end
 
   def score(metric_ranking, item)
-    ScoringStrategies.identity(metric_ranking, item)
+    MetricFu::HotspotScoringStrategies.identity(metric_ranking, item)
   end
 
   def generate_records(data, table)

data/lib/metrics/hotspot_analyzer.rb

@@ -0,0 +1,328 @@
+%w(record grouping).each do |path|
+  MetricFu.data_structures_require { path }
+end
+
+module MetricFu
+  class HotspotAnalyzer
+
+    COMMON_COLUMNS = %w{metric}
+    GRANULARITIES =  %w{file_path class_name method_name}
+
+    attr_accessor :table
+
+    def initialize(yaml)
+      if(yaml.is_a?(String))
+         @yaml = YAML.load(yaml)
+       else
+         @yaml = yaml
+       end
+      @file_ranking = MetricFu::Ranking.new
+      @class_ranking = MetricFu::Ranking.new
+      @method_ranking = MetricFu::Ranking.new
+      rankings = [@file_ranking, @class_ranking, @method_ranking]
+
+      tool_analyzers = [ReekHotspot.new, RoodiHotspot.new,
+      FlogHotspot.new, ChurnHotspot.new, SaikuroHotspot.new,
+      FlayHotspot.new, StatsHotspot.new, RcovHotspot.new]
+      # TODO There is likely a clash that will happen between
+      # column names eventually. We should probably auto-prefix
+      # them (e.g. "roodi_problem")
+      columns = COMMON_COLUMNS + GRANULARITIES + tool_analyzers.map{|analyzer| analyzer.columns}.flatten
+
+      @table = make_table(columns)
+
+      # These tables are an optimization. They contain subsets of the master table.
+      # TODO - these should be pushed into the Table class now
+      @tool_tables   = make_table_hash(columns)
+      @file_tables   = make_table_hash(columns)
+      @class_tables  = make_table_hash(columns)
+      @method_tables = make_table_hash(columns)
+
+      tool_analyzers.each do |analyzer|
+        analyzer.generate_records(@yaml[analyzer.name], @table)
+      end
+
+      build_lookups!(table)
+      process_rows!(table)
+
+      tool_analyzers.each do |analyzer|
+        GRANULARITIES.each do |granularity|
+          metric_ranking = calculate_metric_scores(granularity, analyzer)
+          add_to_master_ranking(ranking(granularity), metric_ranking, analyzer)
+        end
+      end
+
+      rankings.each do |ranking|
+        ranking.delete(nil)
+      end
+    end
+
+    def location(item, value)
+      sub_table = get_sub_table(item, value)
+      if(sub_table.length==0)
+        raise MetricFu::AnalysisError, "The #{item.to_s} '#{value.to_s}' does not have any rows in the analysis table"
+      else
+        first_row = sub_table[0]
+        case item
+        when :class
+          MetricFu::Location.get(first_row.file_path, first_row.class_name, nil)
+        when :method
+          MetricFu::Location.get(first_row.file_path, first_row.class_name, first_row.method_name)
+        when :file
+          MetricFu::Location.get(first_row.file_path, nil, nil)
+        else
+          raise ArgumentError, "Item must be :class, :method, or :file"
+        end
+      end
+    end
+
+    #todo redo as item,value, options = {}
+    # Note that the other option for 'details' is :detailed (this isn't
+    # at all clear from this method itself
+    def problems_with(item, value, details = :summary, exclude_details = [])
+      sub_table = get_sub_table(item, value)
+      #grouping = Ruport::Data::Grouping.new(sub_table, :by => 'metric')
+      grouping = get_grouping(sub_table, :by => 'metric')
+      problems = {}
+      grouping.each do |metric, table|
+        if details == :summary || exclude_details.include?(metric)
+          problems[metric] = present_group(metric,table)
+        else
+          problems[metric] = present_group_details(metric,table)
+        end
+      end
+      problems
+    end
+
+    def worst_methods(size = nil)
+      @method_ranking.top(size)
+    end
+
+    def worst_classes(size = nil)
+      @class_ranking.top(size)
+    end
+
+    def worst_files(size = nil)
+      @file_ranking.top(size)
+    end
+
+    private
+
+    def get_grouping(table, opts)
+      #Ruport::Data::Grouping.new(table, opts)
+      MetricFu::Grouping.new(table, opts)
+      #@grouping_cache ||= {}
+      #@grouping_cache.fetch(grouping_key(table,opts)) do
+      #  @grouping_cache[grouping_key(table,opts)] = Ruport::Data::Grouping.new(table, opts)
+      #end
+    end
+
+    def grouping_key(table, opts)
+      "table #{table.object_id} opts #{opts.inspect}"
+    end
+
+    def build_lookups!(table)
+      @class_and_method_to_file ||= {}
+      # Build a mapping from [class,method] => filename
+      # (and make sure the mapping is unique)
+      table.each do |row|
+        # We know that Saikuro provides the wrong data
+        next if row['metric'] == :saikuro
+        key = [row['class_name'], row['method_name']]
+        file_path = row['file_path']
+        @class_and_method_to_file[key] ||= file_path
+      end
+    end
+
+    def process_rows!(table)
+      # Correct incorrect rows in the table
+      table.each do |row|
+        row_metric = row['metric'] #perf optimization
+        if row_metric == :saikuro
+          fix_row_file_path!(row)
+        end
+        @tool_tables[row_metric] << row
+        @file_tables[row["file_path"]] << row
+        @class_tables[row["class_name"]] << row
+        @method_tables[row["method_name"]] << row
+      end
+    end
+
+    def fix_row_file_path!(row)
+      # We know that Saikuro rows are broken
+      # next unless row['metric'] == :saikuro
+      key = [row['class_name'], row['method_name']]
+      current_file_path = row['file_path'].to_s
+      correct_file_path = @class_and_method_to_file[key]
+      if(correct_file_path!=nil && correct_file_path.include?(current_file_path))
+        row['file_path'] = correct_file_path
+      else
+        # There wasn't an exact match, so we can do a substring match
+        matching_file_path = file_paths.detect {|file_path|
+          file_path!=nil && file_path.include?(current_file_path)
+        }
+        if(matching_file_path)
+          row['file_path'] = matching_file_path
+        end
+      end
+    end
+
+    def file_paths
+      @file_paths ||= @table.column('file_path').uniq
+    end
+
+    def ranking(column_name)
+      case column_name
+      when "file_path"
+        @file_ranking
+      when "class_name"
+        @class_ranking
+      when "method_name"
+        @method_ranking
+      else
+        raise ArgumentError, "Invalid column name #{column_name}"
+      end
+    end
+
+    def calculate_metric_scores(granularity, analyzer)
+      metric_ranking = MetricFu::Ranking.new
+      metric_violations = @tool_tables[analyzer.name]
+      metric_violations.each do |row|
+        location = row[granularity]
+        metric_ranking[location] ||= []
+        metric_ranking[location] << analyzer.map(row)
+      end
+
+      metric_ranking.each do |item, scores|
+        metric_ranking[item] = analyzer.reduce(scores)
+      end
+
+      metric_ranking
+    end
+
+    def add_to_master_ranking(master_ranking, metric_ranking, analyzer)
+      metric_ranking.each do |item, _|
+        master_ranking[item] ||= 0
+        master_ranking[item] += analyzer.score(metric_ranking, item) # scaling? Do we just add in the raw score?
+      end
+    end
+
+    def most_common_column(column_name, size)
+      #grouping = Ruport::Data::Grouping.new(@table,
+      #                                      :by => column_name,
+      #                                      :order => lambda { |g| -g.size})
+      get_grouping(@table, :by => column_name, :order => lambda {|g| -g.size})
+      values = []
+      grouping.each do |value, _|
+        values << value if value!=nil
+        if(values.size==size)
+          break
+        end
+      end
+      return nil if values.empty?
+      if(values.size == 1)
+        return values.first
+      else
+        return values
+      end
+    end
+
+    # TODO: As we get fancier, the presenter should
+    # be its own class, not just a method with a long
+    # case statement
+    def present_group(metric, group)
+      occurences = group.size
+      case(metric)
+      when :reek
+        "found #{occurences} code smells"
+      when :roodi
+        "found #{occurences} design problems"
+      when :churn
+        "detected high level of churn (changed #{group[0].times_changed} times)"
+      when :flog
+        complexity = get_mean(group.column("score"))
+        "#{"average " if occurences > 1}complexity is %.1f" % complexity
+      when :saikuro
+        complexity = get_mean(group.column("complexity"))
+        "#{"average " if occurences > 1}complexity is %.1f" % complexity
+      when :flay
+        "found #{occurences} code duplications"
+      when :rcov
+        average_code_uncoverage = get_mean(group.column("percentage_uncovered"))
+        "#{"average " if occurences > 1}uncovered code is %.1f%" % average_code_uncoverage
+      else
+        raise MetricFu::AnalysisError, "Unknown metric #{metric}"
+      end
+    end
+
+    def present_group_details(metric, group)
+      occurences = group.size
+      case(metric)
+      when :reek
+        message = "found #{occurences} code smells<br/>"
+        group.each do |item|
+          type    = item.data["reek__type_name"]
+          reek_message = item.data["reek__message"]
+          message << "* #{type}: #{reek_message}<br/>"
+        end
+        message
+      when :roodi
+        message = "found #{occurences} design problems<br/>"
+        group.each do |item|
+          problem    = item.data["problems"]
+          message << "* #{problem}<br/>"
+        end
+        message
+      when :churn
+        "detected high level of churn (changed #{group[0].times_changed} times)"
+      when :flog
+        complexity = get_mean(group.column("score"))
+        "#{"average " if occurences > 1}complexity is %.1f" % complexity
+      when :saikuro
+        complexity = get_mean(group.column("complexity"))
+        "#{"average " if occurences > 1}complexity is %.1f" % complexity
+      when :flay
+        message = "found #{occurences} code duplications<br/>"
+        group.each do |item|
+          problem    = item.data["flay_reason"]
+          problem    = problem.gsub(/^[0-9]*\)/,'')
+          problem    = problem.gsub(/files\:/,' <br>&nbsp;&nbsp;&nbsp;files:')
+          message << "* #{problem}<br/>"
+        end
+        message
+      else
+        raise MetricFu::AnalysisError, "Unknown metric #{metric}"
+      end
+    end
+
+    def make_table_hash(columns)
+      Hash.new { |hash, key|
+        hash[key] = make_table(columns)
+      }
+    end
+
+    def make_table(columns)
+      MetricFu::Table.new(:column_names => columns)
+    end
+
+    def get_sub_table(item, value)
+      tables = {
+        :class  => @class_tables,
+        :method => @method_tables,
+        :file   => @file_tables,
+        :tool   => @tool_tables
+      }.fetch(item) do
+        raise ArgumentError, "Item must be :class, :method, or :file"
+      end
+      tables[value]
+    end
+
+    def get_mean(collection)
+      collection_length = collection.length
+      sum = 0
+      sum = collection.inject( nil ) { |sum,x| sum ? sum+x : x }
+      (sum.to_f / collection_length.to_f)
+    end
+
+  end
+end

data/lib/metrics/hotspots/hotspots.rb

@@ -11,7 +11,7 @@ module MetricFu
     end
 
     def emit
-      @analyzer = MetricAnalyzer.new(MetricFu.report.report_hash)
+      @analyzer = MetricFu::HotspotAnalyzer.new(MetricFu.report.report_hash)
     end
 
     def analyze

data/lib/metrics/rcov/{rcov_analyzer.rb → rcov_hotspot.rb}

@@ -1,5 +1,5 @@
-class RcovAnalyzer
-  include ScoringStrategies
+class RcovHotspot
+  include MetricFu::HotspotScoringStrategies
 
   COLUMNS = %w{percentage_uncovered}
 
@@ -16,11 +16,11 @@ class RcovAnalyzer
   end
 
   def reduce(scores)
-    ScoringStrategies.average(scores)
+    MetricFu::HotspotScoringStrategies.average(scores)
   end
 
   def score(metric_ranking, item)
-    ScoringStrategies.identity(metric_ranking, item)
+    MetricFu::HotspotScoringStrategies.identity(metric_ranking, item)
   end
 
   def generate_records(data, table)

data/lib/metrics/reek/{reek_analyzer.rb → reek_hotspot.rb}

@@ -1,7 +1,7 @@
 # coding: utf-8
 
-class ReekAnalyzer
-  include ScoringStrategies
+class ReekHotspot
+  include MetricFu::HotspotScoringStrategies
 
   REEK_ISSUE_INFO = {
     'Uncommunicative Name' =>
@@ -71,7 +71,7 @@ class ReekAnalyzer
 
   # Note that in practice, the prefix reek__ is appended to each one
   # This was a partially implemented idea to avoid column name collisions
-  # but it is only done in the ReekAnalyzer
+  # but it is only done in the ReekHotspot
   COLUMNS = %w{type_name message value value_description comparable_message}
 
   def self.issue_link(issue)
@@ -87,15 +87,15 @@ class ReekAnalyzer
   end
 
   def map(row)
-    ScoringStrategies.present(row)
+    MetricFu::HotspotScoringStrategies.present(row)
   end
 
   def reduce(scores)
-    ScoringStrategies.sum(scores)
+    MetricFu::HotspotScoringStrategies.sum(scores)
   end
 
   def score(metric_ranking, item)
-    ScoringStrategies.percentile(metric_ranking, item) 
+    MetricFu::HotspotScoringStrategies.percentile(metric_ranking, item)
   end
 
   def generate_records(data, table)
@@ -109,7 +109,7 @@ class ReekAnalyzer
         table << {
           "metric" => name, # important
           "file_path" => file_path, # important
-          # NOTE: ReekAnalyzer is currently different than other analyzers with regard
+          # NOTE: ReekHotspot is currently different than other hotspots with regard
           # to column name. Note the COLUMNS constant and #columns method
           "reek__message" => message,
           "reek__type_name" => smell_type,