fastruby-metric_fu 5.0.0

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

@@ -0,0 +1,23 @@
+%w(table).each do |path|
+  MetricFu.metrics_require   { "hotspots/analysis/#{path}" }
+end
+module MetricFu
+  class Grouping
+    def initialize(table, opts)
+      column_name = opts.fetch(:by)
+      hash = {}
+      if column_name.to_sym == :metric # special optimized case
+        hash = table.group_by_metric
+      else
+        raise "Unexpected column_name #{column_name}"
+      end
+      @arr = hash.to_a
+    end
+
+    def each
+      @arr.each do |value, rows|
+        yield value, rows
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+MetricFu.metrics_require { "hotspots/analysis/grouping" }
+module MetricFu
+  class HotspotGroupings
+    def initialize(table, opts)
+      @table, @opts = table, opts
+    end
+
+    def get_grouping
+      MetricFu::Grouping.new(@table, @opts)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+MetricFu.metrics_require { "hotspots/analysis/groupings" }
+module MetricFu
+  class HotspotProblems
+    def initialize(sub_table)
+      @grouping = group_by(sub_table, "metric")
+    end
+
+    def problems
+      problems = {}
+      @grouping.each do |metric, table|
+        problems[metric] = MetricFu::Hotspot.analyzer_for_metric(metric).present_group(table)
+      end
+      problems
+    end
+
+    def group_by(sub_table, by = "metric")
+      MetricFu::HotspotGroupings.new(sub_table, by: by).get_grouping
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+MetricFu.lib_require { "errors/analysis_error" }
+MetricFu.metrics_require { "hotspots/analysis/problems" }
+module MetricFu
+  class HotspotRankedProblemLocation
+    MetricFu.data_structures_require { "location" }
+    attr_reader :sub_table, :granularity
+    def initialize(sub_table, granularity)
+      @sub_table = sub_table
+      @granularity = granularity
+    end
+
+    def to_hash
+      {
+        "location" => location.to_hash,
+        "details" =>  MetricFu::Utility.stringify_keys(problems),
+      }
+    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
+      @problems ||= MetricFu::HotspotProblems.new(sub_table).problems
+    end
+
+    def location
+      @location ||= case granularity
+                    when :class  then class_location
+                    when :method then method_location
+                    when :file   then file_location
+                    else              raise ArgumentError, "Item must be :class, :method, or :file"
+                    end
+    end
+
+    def file_path
+      first_row.file_path
+    end
+
+    def class_name
+      first_row.class_name
+    end
+
+    def method_name
+      first_row.method_name
+    end
+
+    def file_location
+      MetricFu::Location.get(file_path, nil, nil)
+    end
+
+    def method_location
+      MetricFu::Location.get(file_path, class_name, method_name)
+    end
+
+    def class_location
+      MetricFu::Location.get(file_path, class_name, nil)
+    end
+
+    def first_row
+      assert_sub_table_has_data
+      @first_row ||= sub_table[0]
+    end
+
+    def assert_sub_table_has_data
+      if (sub_table.length == 0)
+        raise MetricFu::AnalysisError, "The #{item} '#{value}' does not have any rows in the analysis table"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require "forwardable"
+module MetricFu
+  class Ranking
+    extend Forwardable
+
+    def initialize
+      @items_to_score = {}
+    end
+
+    def top
+      sorted_items
+    end
+
+    def percentile(item)
+      index = sorted_items.index(item)
+      worse_item_count = (length - (index + 1))
+      worse_item_count.to_f / length
+    end
+
+    def_delegator :@items_to_score, :has_key?, :scored?
+    def_delegators :@items_to_score, :[], :[]=, :length, :each, :delete, :fetch
+
+    private
+
+    def sorted_items
+      @sorted_items ||= @items_to_score.sort_by { |_item, score| -score }.map { |item, _score| item }
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+MetricFu.metrics_require do
+  [
+    "hotspots/analysis/ranking"
+  ]
+end
+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
+      @method_ranking.delete(nil)
+      @method_ranking.top
+    end
+
+    def worst_classes
+      @class_ranking.delete(nil)
+      @class_ranking.top
+    end
+
+    def worst_files
+      @file_ranking.delete(nil)
+      @file_ranking.top
+    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
+
+    # CALCULATES METRIC HOTSPOT SCORES / RANKINGS PER map/reduce in HOTSPOT subclasses
+    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/analysis/record.rb

@@ -0,0 +1,32 @@
+module MetricFu
+  class Record
+    attr_reader :data
+
+    def initialize(data, _columns)
+      @data = data
+    end
+
+    def method_missing(name, *args, &block)
+      key = name.to_s
+      if key == "fetch"
+        @data.send(name, *args, &block)
+      elsif @data.has_key?(key)
+        @data[key]
+      else
+        super(name, *args, &block)
+      end
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def has_key?(key)
+      @data.has_key?(key)
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module MetricFu
+  module HotspotScoringStrategies
+    module_function
+
+    # per project score percentile
+    def percentile(ranking, item)
+      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.fetch(item)
+    end
+
+    def sum(scores)
+      scores.inject(&:+)
+    end
+
+    def average(scores)
+      sum(scores).to_f / scores.size.to_f
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+%w(record).each do |path|
+  MetricFu.metrics_require   { "hotspots/analysis/#{path}" }
+end
+
+module MetricFu
+  class Table
+    include Enumerable
+
+    def initialize(opts = {})
+      @rows = []
+      @columns = opts.fetch(:column_names)
+
+      @make_index = opts.fetch(:make_index) { true }
+      @metric_index = {}
+    end
+
+    def <<(row)
+      record = nil
+      if row.is_a?(MetricFu::Record)
+        record = row
+      else
+        record = MetricFu::Record.new(row, @columns)
+      end
+      @rows << record
+      updated_key_index(record) if @make_index
+    end
+
+    def each
+      @rows.each do |row|
+        yield row
+      end
+    end
+
+    def size
+      length
+    end
+
+    def length
+      @rows.length
+    end
+
+    def [](index)
+      @rows[index]
+    end
+
+    def column(column_name)
+      arr = []
+      @rows.each do |row|
+        arr << row[column_name]
+      end
+      arr
+    end
+
+    def group_by_metric
+      @metric_index.to_a
+    end
+
+    private
+
+    def updated_key_index(record)
+      if record.has_key?("metric")
+        @metric_index[record.metric] ||= MetricFu::Table.new(column_names: @columns, make_index: false)
+        @metric_index[record.metric] << record
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+MetricFu.metrics_require   { "hotspots/hotspot_analyzer" }
+module MetricFu
+  class HotspotsGenerator < Generator
+    def self.metric
+      :hotspots
+    end
+
+    def initialize(options = {})
+      MetricFu::Metric.enabled_metrics.each do |metric|
+        require_hotspot(metric.name)
+      end
+      super
+    end
+
+    def emit
+      # no-op
+    end
+
+    def analyze
+      analyzer = MetricFu::HotspotAnalyzer.new(MetricFu.result.result_hash)
+      @hotspots = analyzer.hotspots
+    end
+
+    def to_h
+      result = { hotspots: {} }
+      @hotspots.each do |granularity, hotspots|
+        result[:hotspots][granularity.to_s] = hotspots.map(&:to_hash)
+      end
+      result
+    end
+
+    private
+
+    def require_hotspot(metric_name)
+      require "metric_fu/metrics/#{metric_name}/hotspot"
+    rescue LoadError
+      mf_debug "*** No hotspot for #{metric_name}"
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+MetricFu.lib_require { "errors/analysis_error" }
+MetricFu.metrics_require { "hotspots/analysis/scoring_strategies" }
+
+module MetricFu
+  class Hotspot
+    def self.metric
+      name.split("::")[-1].split("Hotspot")[0].downcase.to_sym
+    end
+    @analyzers = {}
+    def self.analyzers
+      @analyzers.values
+    end
+    def self.analyzer_for_metric(metric)
+      @analyzers.fetch(metric.to_sym) do
+        message = "Unknown metric #{metric}. We only know #{@analyzers.keys.inspect}"
+        fail MetricFu::AnalysisError, message
+      end
+    end
+    def self.inherited(subclass)
+      mf_debug "Adding #{subclass} to #{@analyzers.inspect}"
+      @analyzers[subclass.metric] = subclass.new
+    end
+
+    def get_mean(collection)
+      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) do
+        fail "#{reduce_strategy} not a known reduce strategy"
+      end
+    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