metric_fu 4.4.0 → 4.4.1

data/lib/metric_fu/metrics/hotspots/analysis/analyzer_tables.rb

@@ -97,12 +97,6 @@ module MetricFu
       @file_paths ||= @table.column('file_path').uniq
     end
 
-    # These tables are an optimization. They contain subsets of the master table.
-    # TODO - these should be pushed into the Table class now
-    def optimized_tables
-      @optimized_tables ||= make_table_hash(@columns)
-    end
-
     def file_tables
       @file_tables  ||= make_table_hash(@columns)
     end

data/lib/metric_fu/metrics/hotspots/analysis/grouping.rb

@@ -6,28 +6,13 @@ module MetricFu
 
     def initialize(table, opts)
       column_name = opts.fetch(:by)
-      order = opts.fetch(:order) { nil }
       hash = {}
       if column_name.to_sym == :metric # special optimized case
         hash = table.group_by_metric
       else
-        table.each do |row|
-          hash[row[column_name]] ||= MetricFu::Table.new(:column_names => row.attributes)
-          hash[row[column_name]] << row
-        end
+        raise "Unexpected column_name #{column_name}"
       end
-      if order
-        @arr = hash.sort_by(&order)
-      else
-        @arr = hash.to_a
-      end
-    end
-
-    def [](key)
-      @arr.each do |group_key, table|
-        return table if group_key == key
-      end
-      return nil
+      @arr = hash.to_a
     end
 
     def each

data/lib/metric_fu/metrics/hotspots/analysis/groupings.rb

@@ -4,18 +4,10 @@ module MetricFu
     def initialize(table, opts)
       @table, @opts = table, opts
     end
+
     def get_grouping
-      #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
 
-    # UNUSED
-    # def grouping_key(table, opts)
-    #   "table #{table.object_id} opts #{opts.inspect}"
-    # end
   end
 end

data/lib/metric_fu/metrics/hotspots/analysis/problems.rb

@@ -1,18 +1,14 @@
 module MetricFu
   class HotspotProblems
 
-    def initialize(grouping, details, exclude_details)
-      @grouping, @details, @exclude_details = grouping, details, exclude_details
+    def initialize(grouping)
+      @grouping = grouping
     end
 
     def problems
       problems = {}
       @grouping.each do |metric, table|
-        if @details == :summary || @exclude_details.include?(metric)
-          problems[metric] = MetricFu::Hotspot.analyzer_for_metric(metric).present_group(table)
-        else
-          problems[metric] = MetricFu::Hotspot.analyzer_for_metric(metric).present_group_details(table)
-        end
+        problems[metric] = MetricFu::Hotspot.analyzer_for_metric(metric).present_group(table)
       end
       problems
     end

data/lib/metric_fu/metrics/hotspots/analysis/ranking.rb

@@ -7,12 +7,8 @@ module MetricFu
       @items_to_score = {}
     end
 
-    def top(num=nil)
-      if(num.is_a?(Numeric))
-        sorted_items[0,num]
-      else
-        sorted_items
-      end
+    def top
+      sorted_items
     end
 
     def percentile(item)
@@ -22,7 +18,7 @@ module MetricFu
     end
 
     def_delegator :@items_to_score, :has_key?, :scored?
-    def_delegators :@items_to_score, :[], :[]=, :length, :each, :delete
+    def_delegators :@items_to_score, :[], :[]=, :length, :each, :delete, :fetch
 
     private
 

data/lib/metric_fu/metrics/hotspots/analysis/rankings.rb

@@ -14,19 +14,19 @@ module MetricFu
       end
     end
 
-    def worst_methods(size = nil)
+    def worst_methods
       @method_ranking.delete(nil)
-      @method_ranking.top(size)
+      @method_ranking.top
     end
 
-    def worst_classes(size = nil)
+    def worst_classes
       @class_ranking.delete(nil)
-      @class_ranking.top(size)
+      @class_ranking.top
     end
 
-    def worst_files(size = nil)
+    def worst_files
       @file_ranking.delete(nil)
-      @file_ranking.top(size)
+      @file_ranking.top
     end
 
     private

data/lib/metric_fu/metrics/hotspots/analysis/record.rb

@@ -5,15 +5,14 @@ module MetricFu
 
     def initialize(data, columns)
       @data = data
-      @columns = columns
     end
 
     def method_missing(name, *args, &block)
       key = name.to_s
-      if @data.has_key?(key)
+      if key == 'fetch'
+        @data.send(name, *args, &block)
+      elsif @data.has_key?(key)
         @data[key]
-      elsif @columns.member?(key)
-        nil
       else
         super(name, *args, &block)
       end
@@ -27,17 +26,9 @@ module MetricFu
       @data[key]
     end
 
-    def keys
-      @data.keys
-    end
-
     def has_key?(key)
       @data.has_key?(key)
     end
 
-    def attributes
-      @columns
-    end
-
   end
 end

data/lib/metric_fu/metrics/hotspots/analysis/scoring_strategies.rb

@@ -1,31 +1,26 @@
 module MetricFu
   module HotspotScoringStrategies
 
+    module_function
+
+    # per project score percentile
     def percentile(ranking, item)
-      ranking.percentile(item) # per project score percentile
+      ranking.percentile(item)
     end
 
+    # Use the score you got
+    #   (ex flog score of 20 is not bad even if it is the top one in project)
     def identity(ranking, item)
-      ranking[item] # Use the score you got (ex flog score of 20 is not bad even if it is the top one in project)
-    end
-
-    def present(row)
-      1 # If present it's a one, not present it's a zero - For things like Reek that don't have a number
+      ranking.fetch(item)
     end
 
     def sum(scores)
-      scores.inject(0) {|s,x| s+x}
+      scores.inject(&:+)
     end
 
     def average(scores)
-      # remove dependency on statarray
-      # scores.to_statarray.mean
-      score_length = scores.length
-      total = 0
-      total= scores.inject( nil ) { |sum,x| sum ? sum+x : x }
-      (total.to_f / score_length.to_f)
+      sum(scores).to_f / scores.size.to_f
     end
 
-    extend self
   end
 end

data/lib/metric_fu/metrics/hotspots/analysis/table.rb

@@ -1,9 +1,10 @@
-%w(record code_issue).each do |path|
+%w(record).each do |path|
   MetricFu.metrics_require   { "hotspots/analysis/#{path}" }
 end
 
 module MetricFu
   class Table
+    include Enumerable
 
     def initialize(opts = {})
       @rows = []
@@ -15,7 +16,7 @@ module MetricFu
 
     def <<(row)
       record = nil
-      if row.is_a?(MetricFu::Record) || row.is_a?(MetricFu::CodeIssue)
+      if row.is_a?(MetricFu::Record)
         record = row
       else
         record = MetricFu::Record.new(row, @columns)
@@ -54,49 +55,8 @@ module MetricFu
       @metric_index.to_a
     end
 
-    def rows_with(conditions)
-      if optimized_conditions?(conditions)
-        optimized_select(conditions)
-      else
-        slow_select(conditions)
-      end
-    end
-
-    def delete_at(index)
-      @rows.delete_at(index)
-    end
-
-    def to_a
-      @rows
-    end
-
-    def map
-      new_table = MetricFu::Table.new(:column_names => @columns)
-      @rows.map do |row|
-        new_table << (yield row)
-      end
-      new_table
-    end
-
     private
 
-    def optimized_conditions?(conditions)
-      conditions.keys.length == 1 && conditions.keys.first.to_sym == :metric
-    end
-
-    def optimized_select(conditions)
-      metric = (conditions['metric'] || conditions[:metric]).to_s
-      @metric_index[metric].to_a.clone
-    end
-
-    def slow_select(conditions)
-      @rows.select do |row|
-        conditions.all? do |key, value|
-          row.has_key?(key.to_s) && row[key.to_s] == value
-        end
-      end
-    end
-
     def updated_key_index(record)
       if record.has_key?('metric')
         @metric_index[record.metric] ||= MetricFu::Table.new(:column_names => @columns, :make_index => false)

data/lib/metric_fu/metrics/hotspots/hotspot.rb

@@ -1,7 +1,7 @@
 module MetricFu
   class Hotspot
     def self.metric
-      self.name.split('Hotspot')[0].downcase.to_sym
+      self.name.split('::')[-1].split('Hotspot')[0].downcase.to_sym
     end
     @analyzers = {}
     def self.analyzers
@@ -18,13 +18,65 @@ module MetricFu
       @analyzers[subclass.metric] = subclass.new
     end
 
-    # TODO simplify calculation
-    # DUPLICATES CODE IN ScoringStrategies
     def get_mean(collection)
-      collection_length = collection.length
-      total = 0
-      total = collection.inject( nil ) { |sum,x| sum ? sum+x : x }
-      (total.to_f / collection_length.to_f)
+      MetricFu::HotspotScoringStrategies.average(collection)
+    end
+
+    def map(row)
+      mapping_strategies.fetch(map_strategy) { row.public_send(map_strategy) }
+    end
+
+    def mapping_strategies
+      {
+        :present => 1,
+        :absent  => 0,
+      }
+    end
+
+    def map_strategy
+      not_implemented
+    end
+
+    def reduce(scores)
+      {
+        :average => MetricFu::HotspotScoringStrategies.average(scores),
+        :sum     => MetricFu::HotspotScoringStrategies.sum(scores),
+        :absent  => 0,
+      }.fetch(reduce_strategy) { raise "#{reduce_strategy} not a know reduce strategy" }
+    end
+
+    def reduce_strategy
+      not_implemented
+    end
+
+    # @return [Integer]
+    def score(metric_ranking, item)
+      {
+        :identity   => MetricFu::HotspotScoringStrategies.identity(metric_ranking, item),
+        :percentile => MetricFu::HotspotScoringStrategies.percentile(metric_ranking, item),
+        :absent     => 0,
+      }.fetch(score_strategy) { method(score_strategy).call(metric_ranking, item) }
+    end
+
+    def score_strategy
+      not_implemented
+    end
+
+    # Transforms the data param, if non-nil, into a hash with keys:
+    #   'metric',  etc.
+    #   and appends the hash to the table param
+    #   Has no return value
+    def generate_records(data, table)
+      not_implemented
+    end
+
+    # @return [String] description result
+    def present_group(group)
+      not_implemented
+    end
+
+    def not_implemented
+      raise "#{caller[0]} not implemented"
     end
   end
 end

data/lib/metric_fu/metrics/hotspots/hotspot_analyzer.rb

@@ -11,9 +11,6 @@ module MetricFu
     COMMON_COLUMNS = %w{metric}
     GRANULARITIES =  %w{file_path class_name method_name}
 
-    # TODO , UNUSED
-    # attr_accessor :table
-
     def tool_analyzers
       MetricFu::Hotspot.analyzers
     end
@@ -25,7 +22,6 @@ module MetricFu
       setup(result_hash)
     end
 
-    # def worst_items; previous method name
     def hotspots
       analyzed_problems.worst_items
     end
@@ -33,14 +29,6 @@ module MetricFu
     def analyzed_problems
       @analyzed_problems = MetricFu::HotspotAnalyzedProblems.new(@rankings, @analyzer_tables)
     end
-    # just for testing
-    # TODO remove the delegators
-    # and refactor the tests
-    alias_method :worst_items, :hotspots
-    extend Forwardable
-    def_delegators  :@analyzer_tables, :table
-    def_delegators  :@analyzed_problems, :problems_with, :location
-    def_delegators  :@rankings, :worst_files, :worst_methods, :worst_classes
 
     private
 
@@ -52,7 +40,7 @@ module MetricFu
       # TODO There is likely a clash that will happen between
       # column names eventually. We should probably auto-prefix
       # them (e.g. "roodi_problem")
-      analyzer_columns = COMMON_COLUMNS + GRANULARITIES + tool_analyzers.map{|analyzer| analyzer.columns}.flatten
+      analyzer_columns = COMMON_COLUMNS + GRANULARITIES + tool_analyzers.map(&:columns).flatten
       # though the tool_analyzers aren't returned, they are processed in
       # various places here, then by the analyzer tables
       # then by the rankings
@@ -64,33 +52,10 @@ module MetricFu
       @analyzer_tables.generate_records
       @rankings = MetricFu::HotspotRankings.new(@analyzer_tables.tool_tables)
       @rankings.calculate_scores(tool_analyzers, GRANULARITIES)
-      # just for testing
       # TODO does it not need to return something here?
       analyzed_problems
     end
 
-    # TODO remove, UNUSED
-    # 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
-
-
 
   end
 end

data/lib/metric_fu/metrics/hotspots/hotspots.rb

@@ -11,10 +11,6 @@ module MetricFu
       super
     end
 
-    def self.verify_dependencies!
-      true
-    end
-
     def emit
       @analyzer = MetricFu::HotspotAnalyzer.new(MetricFu.result.result_hash)
     end