metric_fu 4.1.0 → 4.1.1

data/lib/metric_fu/metrics/flog/flog_gchart_grapher.rb

@@ -0,0 +1,21 @@
+MetricFu.metrics_require   { 'flog/flog_grapher' }
+module MetricFu
+  class FlogGchartGrapher < FlogGrapher
+    def graph!
+      determine_y_axis_scale(@top_five_percent_average + @flog_average)
+      url = Gchart.line(
+        :size => GCHART_GRAPH_SIZE,
+        :title => URI.escape("Flog: code complexity"),
+        :data => [@flog_average, @top_five_percent_average],
+        :stacked => false,
+        :bar_colors => COLORS[0..1],
+        :legend => ['average', 'top 5% average'],
+        :custom => "chdlp=t",
+        :max_value => @max_value,
+        :axis_with_labels => 'x,y',
+        :axis_labels => [@labels.values, @yaxis],
+        :format => 'file',
+        :filename => File.join(MetricFu.output_directory, 'flog.png'))
+    end
+  end
+end

data/lib/metric_fu/metrics/flog/flog_grapher.rb

@@ -1,3 +1,4 @@
+MetricFu.reporting_require { 'graphs/grapher' }
 module MetricFu
   class FlogGrapher < Grapher
     attr_accessor :flog_average, :labels, :top_five_percent_average

data/lib/metric_fu/metrics/flog/flog_hotspot.rb

@@ -1,4 +1,4 @@
-class FlogHotspot
+class FlogHotspot < MetricFu::Hotspot
   include MetricFu::HotspotScoringStrategies
 
   COLUMNS = %w{score}
@@ -40,4 +40,16 @@ class FlogHotspot
     end
   end
 
+  def present_group(group)
+    occurences = group.size
+    complexity = get_mean(group.column("score"))
+    "#{"average " if occurences > 1}complexity is %.1f" % complexity
+  end
+
+  def present_group_details(group)
+    occurences = group.size
+    complexity = get_mean(group.column("score"))
+    "#{"average " if occurences > 1}complexity is %.1f" % complexity
+  end
+
 end

data/lib/metric_fu/metrics/flog/init.rb

@@ -1,4 +1,5 @@
 MetricFu::Configuration.run do |config|
+  require 'flog'
   config.add_metric(:flog)
   config.add_graph(:flog)
   config.configure_metric(:flog,

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

@@ -0,0 +1,73 @@
+module MetricFu
+  class HotspotAnalyzedProblems
+
+
+    def initialize(hotspot_rankings, analyzer_tables)
+      @hotspot_rankings = hotspot_rankings
+      @analyzer_tables = analyzer_tables
+    end
+    def worst_items
+      num = nil
+      worst_items = {}
+      worst_items[:files] =
+        @hotspot_rankings.worst_files(num).inject([]) do |array, worst_file|
+        array <<
+          {:location => self.location(:file, worst_file),
+          :details => self.problems_with(:file, worst_file)}
+        array
+      end
+      worst_items[:classes] = @hotspot_rankings.worst_classes(num).inject([]) do |array, class_name|
+        location = self.location(:class, class_name)
+        array <<
+          {:location => location,
+          :details => self.problems_with(:class, class_name)}
+        array
+      end
+      worst_items[:methods] = @hotspot_rankings.worst_methods(num).inject([]) do |array, method_name|
+        location = self.location(:method, method_name)
+        array <<
+          {:location => location,
+          :details => self.problems_with(:method, method_name)}
+        array
+      end
+      worst_items
+    end
+    private
+    #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')
+      MetricFu::HotspotProblems.new(grouping, details, exclude_details).problems
+    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
+    # just for testing
+    public :location, :problems_with
+    def get_sub_table(item, value)
+      tables = @analyzer_tables.tables_for(item)
+      tables[value]
+    end
+    def get_grouping(table, opts)
+      MetricFu::HotspotGroupings.new(table, opts).get_grouping
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module MetricFu
+  class AnalyzerTables
+    %w(table).each do |path|
+      MetricFu.metrics_require   { "hotspots/analysis/#{path}" }
+    end
+
+    def initialize(analyzer_columns)
+      @columns = analyzer_columns
+    end
+
+    def generate_records
+      build_lookups!
+      process_rows!
+    end
+
+    def tool_tables
+      @tool_tables ||= make_table_hash(@columns)
+    end
+
+    def table
+      @table ||= make_table(@columns)
+    end
+
+    def tables_for(item)
+      {
+        :class  => @class_tables,
+        :method => @method_tables,
+        :file   => @file_tables,
+        :tool   => @tool_tables
+      }.fetch(item) do
+        raise ArgumentError, "Item must be :class, :method, or :file, but was #{item}"
+      end
+    end
+
+    private
+
+    def make_table(columns)
+      MetricFu::Table.new(:column_names => columns)
+    end
+
+    def make_table_hash(columns)
+      Hash.new { |hash, key|
+        hash[key] = make_table(columns)
+      }
+    end
+
+    def build_lookups!
+      @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
+        # TODO inject Saikuro reference
+        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!
+      # Correct incorrect rows in the table
+      table.each do |row|
+        row_metric = row['metric'] #perf optimization
+        # TODO inject Saikuro reference
+        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
+
+    # 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
+    def class_tables
+      @class_tables  ||= make_table_hash(@columns)
+    end
+    def method_tables
+      @method_tables ||= make_table_hash(@columns)
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module MetricFu
+  class HotspotGroupings
+
+    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

@@ -0,0 +1,21 @@
+module MetricFu
+  class HotspotProblems
+
+    def initialize(grouping, details, exclude_details)
+      @grouping, @details, @exclude_details = grouping, details, exclude_details
+    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
+      end
+      problems
+    end
+
+  end
+end

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

@@ -0,0 +1,81 @@
+module MetricFu
+  class HotspotRankings
+
+    def initialize(tool_tables)
+      @tool_tables = tool_tables
+      @file_ranking = MetricFu::Ranking.new
+      @class_ranking = MetricFu::Ranking.new
+      @method_ranking = MetricFu::Ranking.new
+    end
+
+    def calculate_scores(tool_analyzers, granularities)
+      tool_analyzers.each do |analyzer|
+        calculate_scores_by_granularities(analyzer, granularities)
+      end
+    end
+
+    def worst_methods(size = nil)
+      @method_ranking.delete(nil)
+      @method_ranking.top(size)
+    end
+
+    def worst_classes(size = nil)
+      @class_ranking.delete(nil)
+      @class_ranking.top(size)
+    end
+
+    def worst_files(size = nil)
+      @file_ranking.delete(nil)
+      @file_ranking.top(size)
+    end
+
+    private
+
+    def calculate_scores_by_granularities(analyzer, granularities)
+      granularities.each do |granularity|
+        calculate_score_for_granularity(analyzer, granularity)
+      end
+    end
+
+    def calculate_score_for_granularity(analyzer, granularity)
+      metric_ranking = calculate_metric_scores(granularity, analyzer)
+      add_to_master_ranking(ranking(granularity), metric_ranking, analyzer)
+    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 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 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
+
+  end
+end

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

@@ -0,0 +1,29 @@
+module MetricFu
+  class Hotspot
+    def self.metric
+      self.name.split('Hotspot')[0].downcase.to_sym
+    end
+    @analyzers = {}
+    def self.analyzers
+      @analyzers.values
+    end
+    def self.analyzer_for_metric(metric)
+      mf_debug "Getting analyzer for #{metric}"
+      @analyzers.fetch(metric.to_sym) {
+        raise MetricFu::AnalysisError, "Unknown metric #{metric}. We only know #{@analyzers.keys.inspect}"
+      }
+    end
+    def self.inherited(subclass)
+      mf_debug "Adding #{subclass} to #{@analyzers.inspect}"
+      @analyzers[subclass.metric] = subclass.new
+    end
+
+    # TODO simplify calculation
+    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/metric_fu/metrics/hotspots/hotspot_analyzer.rb

@@ -1,11 +1,9 @@
 require File.expand_path('analysis_error', MetricFu.errors_dir)
 MetricFu.data_structures_require { 'location' }
-%w(table record grouping ranking).each do |path|
+%w(table record grouping ranking problems).each do |path|
   MetricFu.metrics_require   { "hotspots/analysis/#{path}" }
 end
-%w(reek roodi flog churn saikuro flay stats rcov).each do |path|
-  MetricFu.metrics_require   { "#{path}/#{path}_hotspot" }
-end
+MetricFu.metrics_require   { 'hotspots/hotspot' }
 
 module MetricFu
   class HotspotAnalyzer
@@ -13,321 +11,77 @@ module MetricFu
     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
+    # UNUSED
+    # attr_accessor :table
 
-    #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
+    def tool_analyzers
+      MetricFu::Hotspot.analyzers
     end
 
-    def worst_methods(size = nil)
-      @method_ranking.top(size)
+    def initialize(report_hash)
+      # we can't depend on the Report
+      # returning a parsed yaml file as a hash?
+      report_hash = YAML::load(report_hash) if report_hash.is_a?(String)
+      setup(report_hash)
     end
 
-    def worst_classes(size = nil)
-      @class_ranking.top(size)
+    # def worst_items
+    def hotspots
+      analyzed_problems.worst_items
     end
-
-    def worst_files(size = nil)
-      @file_ranking.top(size)
+    # just for testing
+    def analyzed_problems
+      @analyzed_problems = MetricFu::HotspotAnalyzedProblems.new(@rankings, @analyzer_tables)
     end
-
+    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
 
-    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 setup(report_hash)
+      # 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
+      # though the tool_analyzers aren't returned, they are processed in
+      # various places here, then by the analyzer tables
+      # then by the rankings
+      # to ultimately generate the hotspots
+      @analyzer_tables = MetricFu::AnalyzerTables.new(analyzer_columns)
+      tool_analyzers.each do |analyzer|
+        analyzer.generate_records(report_hash[analyzer.name], @analyzer_tables.table)
+      end
+      @analyzer_tables.generate_records
+      @rankings = MetricFu::HotspotRankings.new(@analyzer_tables.tool_tables)
+      @rankings.calculate_scores(tool_analyzers, GRANULARITIES)
+      # just for testing
+      analyzed_problems
+    end
+
+    # 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
 
-    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