fastruby-metric_fu 5.0.0

data/lib/metric_fu/metrics/flay/metric.rb

@@ -0,0 +1,28 @@
+module MetricFu
+  class MetricFlay < Metric
+    def name
+      :flay
+    end
+
+    def default_run_options
+      { dirs_to_flay: MetricFu::Io::FileSystem.directory("code_dirs"),
+        # MetricFu has been setting the minimum score as 100 for
+        # a long time. This is a really big number, considering
+        # the default is 16. Setting it to nil to use the Flay default.
+        minimum_score: nil,
+      }
+    end
+
+    def has_graph?
+      true
+    end
+
+    def enable
+      super
+    end
+
+    def activate
+      super
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+<h3>Flay Results</h3>
+
+<p><a href='http://ruby.sadi.st/Flay.html'>Flay</a> analyzes ruby code for structural similarities.</p>
+
+<%= render_partial 'graph', {:graph_name => 'flay'} %>
+
+<h4>Total Score (lower is better): <%= @flay[:total_score] %></h4>
+<h5>Scores less than <%= MetricFu::Metric.get_metric('flay').run_options[:minimum_score] %> are not shown or part of the total</h5>
+
+<table>
+  <tr>
+    <th>Files</th>
+    <th>Matches</th>
+  </tr>
+  <% count = 0 %>
+  <% @flay[:matches].each do |match| %>
+    <tr class='<%= cycle("light", "dark", count) %>'>
+      <td>
+        <% match[:matches].each do |file| %>
+          <%= link_to_filename(file[:name], file[:line]) %><br/>
+        <% end %>
+      </td>
+      <td><%= match[:reason] %></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+
+<%= render_partial 'report_footer' %>

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

@@ -0,0 +1,113 @@
+require "pathname"
+require "optparse"
+
+module MetricFu
+  class FlogGenerator < Generator
+    def self.metric
+      :flog
+    end
+
+    def emit
+      parse_options = FlogCLI.parse_options [
+        "--all",
+        options[:continue] ? "--continue" : nil,
+      ].compact
+      @flogger = FlogCLI.new parse_options
+      @flogger.flog *files_to_flog
+    end
+
+    def analyze
+      @method_containers = {}
+      @flogger.calculate
+      @flogger.each_by_score do |full_method_name, score, operators|
+        container_name = full_method_name.split("#").first
+        path = @flogger.method_locations[full_method_name]
+        if @method_containers[container_name]
+          @method_containers[container_name].add_method(full_method_name, operators, score, path)
+          @method_containers[container_name].add_path(path)
+        else
+          mc = MethodContainer.new(container_name, path)
+          mc.add_method(full_method_name, operators, score, path)
+          @method_containers[container_name] = mc
+        end
+      end
+    end
+
+    def to_h
+      sorted_containers = @method_containers.values.sort_by(&:highest_score).reverse
+      { flog: { total: @flogger.total_score,
+                average: @flogger.average,
+                method_containers: sorted_containers.map(&:to_h) } }
+    end
+
+    def per_file_info(out)
+      @method_containers.each_pair do |_klass, container|
+        container.methods.each_pair do |_method_name, data|
+          next if data[:path].nil?
+
+          file, line = data[:path].split(":")
+
+          out[file][line] << { type: :flog, description: "Score of %.2f" % data[:score] }
+        end
+      end
+    end
+
+    private
+
+    def files_to_flog
+      options[:dirs_to_flog].flatten.map do |p|
+        if File.directory? p then
+          Dir[File.join(p, '**/*.{rb,rake}')]
+        else
+          p
+        end
+      end.flatten
+    end
+  end
+
+  class MethodContainer
+    attr_reader :methods
+
+    def initialize(name, path)
+      @name = name
+      add_path path
+      @methods = {}
+    end
+
+    def add_path(path)
+      return unless path
+      @path ||= path.split(":").first
+    end
+
+    def add_method(full_method_name, operators, score, path)
+      @methods[full_method_name] = { operators: operators, score: score, path: path }
+    end
+
+    def to_h
+      { name: @name,
+        path: @path || "",
+        total_score: total_score,
+        highest_score: highest_score,
+        average_score: average_score,
+        methods: @methods }
+    end
+
+    def highest_score
+      method_scores.max
+    end
+
+    private
+
+    def method_scores
+      @method_scores ||= @methods.values.map { |v| v[:score] }
+    end
+
+    def total_score
+      @total_score ||= method_scores.inject(0) { |sum, score| sum += score }
+    end
+
+    def average_score
+      total_score / method_scores.size.to_f
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+MetricFu.reporting_require { "graphs/grapher" }
+module MetricFu
+  class FlogGrapher < Grapher
+    attr_accessor :flog_average, :labels, :top_five_percent_average
+
+    def self.metric
+      :flog
+    end
+
+    def initialize
+      super
+      @flog_average = []
+      @labels = {}
+      @top_five_percent_average = []
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:flog]
+        @top_five_percent_average.push(calc_top_five_percent_average(metrics))
+        @flog_average.push(metrics[:flog][:average])
+        @labels.update(@labels.size => date)
+      end
+    end
+
+    def title
+      "Flog: code complexity"
+    end
+
+    def data
+      [
+        ["average", @flog_average.join(",")],
+        ["top 5% average", @top_five_percent_average.join(",")]
+      ]
+    end
+
+    def output_filename
+      "flog.js"
+    end
+
+    private
+
+    def calc_top_five_percent_average(metrics)
+      return calc_top_five_percent_average_legacy(metrics) if metrics[:flog][:pages]
+
+      method_scores = metrics[:flog][:method_containers].inject([]) do |method_scores, container|
+        method_scores += container[:methods].values.map { |v| v[:score] }
+      end
+      method_scores.sort!.reverse!
+
+      number_of_methods_that_is_five_percent = (method_scores.size * 0.05).ceil
+
+      total_for_five_percent =
+        method_scores[0...number_of_methods_that_is_five_percent].inject(0) { |total, score| total += score }
+      if number_of_methods_that_is_five_percent == 0
+        0.0
+      else
+        total_for_five_percent / number_of_methods_that_is_five_percent.to_f
+      end
+    end
+
+    def calc_top_five_percent_average_legacy(metrics)
+      methods = metrics[:flog][:pages].inject([]) { |methods, page| methods << page[:scanned_methods] }
+      methods.flatten!
+      methods = methods.sort_by { |method| method[:score] }.reverse
+
+      number_of_methods_that_is_five_percent = (methods.size * 0.05).ceil
+
+      total_for_five_percent =
+        methods[0...number_of_methods_that_is_five_percent].inject(0) { |total, method| total += method[:score] }
+      if number_of_methods_that_is_five_percent == 0
+        0.0
+      else
+        total_for_five_percent / number_of_methods_that_is_five_percent.to_f
+      end
+    end
+  end
+end

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