code_metric_fu 4.14.0

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

@@ -0,0 +1,46 @@
+class MetricFu::FlogHotspot < MetricFu::Hotspot
+  COLUMNS = %w{score}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :flog
+  end
+
+  def map_strategy
+    :score
+  end
+
+  def reduce_strategy
+    :average
+  end
+
+  def score_strategy
+    :identity
+  end
+
+  def generate_records(data, table)
+    return if data == nil
+    Array(data[:method_containers]).each do |method_container|
+      Array(method_container[:methods]).each do |entry|
+        file_path = entry[1][:path].sub(%r{^/}, "") if entry[1][:path]
+        location = MetricFu::Location.for(entry.first)
+        table << {
+          "metric" => name,
+          "score" => entry[1][:score],
+          "file_path" => file_path,
+          "class_name" => location.class_name,
+          "method_name" => location.method_name
+        }
+      end
+    end
+  end
+
+  def present_group(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/metric.rb

@@ -0,0 +1,29 @@
+module MetricFu
+  class MetricFlog < Metric
+    def name
+      :flog
+    end
+
+    def default_run_options
+      { dirs_to_flog: MetricFu::Io::FileSystem.directory("code_dirs"), continue: true, all: true, quiet: true  }
+    end
+
+    def has_graph?
+      true
+    end
+
+    def enable
+      if MetricFu.configuration.mri?
+        super
+      else
+        MetricFu.logger.debug("Flog is only available in MRI due to flog tasks")
+      end
+    end
+
+    def activate
+      activate_library "flog"
+      activate_library "flog_cli"
+      super
+    end
+  end
+end

data/lib/metric_fu/metrics/flog/report.html.erb

@@ -0,0 +1,50 @@
+<h3>Flog Results</h3>
+<p><a href='http://ruby.sadi.st/Flog.html'>Flog</a> measures code complexity.</p>
+
+<%= render_partial 'graph', {:graph_name => 'flog'} %>
+
+<h2>Total Flog score for all methods: <%= round_to_tenths @flog[:total]%></h2>
+<h2>Average Flog score for all methods: <%= round_to_tenths @flog[:average]%></h2>
+
+<table>
+  <tr>
+    <th>File</th>
+    <th>Total score</th>
+    <th>Methods</th>
+    <th>Average score</th>
+    <th>Highest score</th>
+  </tr>
+    <% @flog[:method_containers].each do |method_container| %>
+    <tr>
+      <td><a href="#<%= method_container[:path].gsub(/[^a-z]+/, '_') %>"><%= method_container[:path] %></a></td>
+      <td><%= round_to_tenths  method_container[:total_score] %></td>
+      <td><%= method_container[:methods].size %></td>
+      <td><%= round_to_tenths method_container[:average_score] %></td>
+      <td><%= round_to_tenths method_container[:highest_score] %></td>
+    </tr>
+  <% end %>
+</table>
+
+<% @flog[:method_containers].each do |method_container| %>
+  <h2 id="<%= method_container[:path].gsub(/[^a-z]+/, '_') %>"><%= link_to_filename(method_container[:path]) %></h2>
+
+    <% method_container[:methods].each do |full_method_name, method_info| %>
+      <% path, line = method_info[:path].split(":") if method_info[:path] %>
+      <p><%= link_to_filename(path, line, full_method_name) %></p>
+      <p>Total Score: <%= round_to_tenths method_info[:score]%></p>
+      <table>
+        <tr>
+          <th>Score</th>
+          <th>Operator</th>
+        </tr>
+        <% method_info[:operators].each do |operator, score| %>
+          <tr>
+            <td><%= round_to_tenths score %></td>
+            <td><%= operator %></td>
+          </tr>
+        <% end %>
+      </table>
+    <% end %>
+<% end %>
+
+<%= render_partial 'report_footer' %>

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

@@ -0,0 +1,34 @@
+module MetricFu
+  class HotspotAnalyzedProblems
+    MetricFu.metrics_require   { "hotspots/analysis/ranked_problem_location" }
+
+    def initialize(hotspot_rankings, analyzer_tables)
+      @hotspot_rankings = hotspot_rankings
+      @analyzer_tables = analyzer_tables
+    end
+
+    def worst_items
+      worst_items = {}
+      worst_items[:files]   = worst(@hotspot_rankings.worst_files,   :file)
+      worst_items[:classes] = worst(@hotspot_rankings.worst_classes, :class)
+      worst_items[:methods] = worst(@hotspot_rankings.worst_methods, :method)
+      worst_items
+    end
+
+    private
+
+    # @param rankings [Array<MetricFu::HotspotRankings>]
+    # @param granularity [Symbol] one of :class, :method, :file
+    def worst(rankings, granularity)
+      rankings.map do |ranked_item_name|
+        sub_table = get_sub_table(granularity, ranked_item_name)
+        MetricFu::HotspotRankedProblemLocation.new(sub_table, granularity)
+      end
+    end
+
+    def get_sub_table(granularity, ranked_item_name)
+      tables = @analyzer_tables.tables_for(granularity)
+      tables[ranked_item_name]
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+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
+
+    # COLLECT AND PROCESS RAW HOTSPOT METRICS
+    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
+
+    # COLLECT AND PROCESS RAW HOTSPOT METRICS
+    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
+
+    # COLLECT AND PROCESS RAW HOTSPOT METRICS
+    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 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/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