code_metric_fu 4.14.0

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

@@ -0,0 +1,87 @@
+<h3>Cane Results</h3>
+
+<p><a href='https://github.com/square/cane'>Cane</a> reports code quality threshold violations.</p>
+
+<%= render_partial 'graph', {:graph_name => 'cane'} %>
+
+<% if @cane[:violations][:abc_complexity] && @cane[:violations][:abc_complexity].size > 0 %>
+<h3>Methods exceeding allowed Abc complexity (<%= @cane[:violations][:abc_complexity].size %>)</h3>
+<table>
+  <tr>
+    <th>File</th>
+    <th>Method</th>
+    <th>Complexity</th>
+  </tr>
+  <% count = 0 %>
+  <% @cane[:violations][:abc_complexity].each do |violation| %>
+    <tr class='<%= cycle("light", "dark", count) %>'>
+      <td><%=link_to_filename(violation[:file])%></td>
+      <td><%=violation[:method]%></td>
+      <td><%=violation[:complexity]%></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+<% end %>
+<% if @cane[:violations][:line_style] && @cane[:violations][:line_style].size > 0 %>
+<h3>Lines violating style requirements (<%= @cane[:violations][:line_style].size %>)</h3>
+<table>
+  <tr>
+    <th>File</th>
+    <th>Description</th>
+  </tr>
+  <% count = 0 %>
+  <% @cane[:violations][:line_style].each do |violation| %>
+    <tr class='<%= cycle("light", "dark", count) %>'>
+      <td><%=link_to_filename(*violation[:line].split(':'))%></td>
+      <td><%=violation[:description]%></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+<% end %>
+<% if @cane[:violations][:documentation] && @cane[:violations][:documentation].size > 0 %>
+<h3>Missing documentation (<%= @cane[:violations][:documentation].size %>)</h3>
+<table>
+  <tr>
+    <th>Description</th>
+  </tr>
+  <% @cane[:violations][:documentation].each do |violation| %>
+    <tr>
+      <td><%=violation[:description]%></td>
+    </tr>
+  <% end %>
+</table>
+<% end %>
+<% if @cane[:violations][:comment] && @cane[:violations][:comment].size > 0 %>
+<h3>Class definitions requiring comments (<%= @cane[:violations][:comment].size %>)</h3>
+<table>
+  <tr>
+    <th>File</th>
+    <th>Class</th>
+  </tr>
+  <% count = 0 %>
+  <% @cane[:violations][:comment].each do |violation| %>
+    <tr class='<%= cycle("light", "dark", count) %>'>
+      <td><%=link_to_filename(*violation[:line].split(':'))%></td>
+      <td><%=violation[:class_name]%></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+<% end %>
+<% if @cane[:violations][:others] && @cane[:violations][:others].size > 0 %>
+<h3>Others (<%= @cane[:violations][:others].size %>)</h3>
+<table>
+  <tr>
+    <th>Description</th>
+  </tr>
+  <% @cane[:violations][:others].each do |violation| %>
+    <tr>
+      <td><%=violation[:description]%></td>
+    </tr>
+  <% end %>
+</table>
+<% end %>
+
+<%= render_partial 'report_footer' %>

data/lib/metric_fu/metrics/cane/violations.rb

@@ -0,0 +1,46 @@
+module MetricFu
+  module CaneViolations
+    class AbcComplexity
+      def self.parse(violation_list)
+        violation_list.split(/\n/).map do |violation|
+          file, method, complexity = violation.split
+          { file: file, method: method, complexity: complexity }
+        end
+      end
+    end
+
+    class LineStyle
+      def self.parse(violation_list)
+        violation_list.split(/\n/).map do |violation|
+          line, description = violation.split(/\s{2,}/).reject { |x|x.strip == "" }
+          { line: line, description: description }
+        end
+      end
+    end
+
+    class Comment
+      def self.parse(violation_list)
+        violation_list.split(/\n/).map do |violation|
+          line, class_name = violation.split
+          { line: line, class_name: class_name }
+        end
+      end
+    end
+
+    class Documentation
+      def self.parse(violation_list)
+        violation_list.split(/\n/).map do |violation|
+          { description: violation.strip }
+        end
+      end
+    end
+
+    class Others
+      def self.parse(violation_list)
+        violation_list.split(/\n/).map do |violation|
+          { description: violation.strip }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module MetricFu
+  class ChurnGenerator < Generator
+    def self.metric
+      :churn
+    end
+
+    ###
+    # options available are what can be passed to churn_calculator
+    # https://github.com/danmayer/churn#library-options
+    ###
+    def emit
+      @output = run(options)
+    end
+
+    def analyze
+      if @output.nil? || @output.size.zero?
+        @churn = { churn: {} }
+      else
+        @churn = @output
+      end
+      @churn
+    end
+
+    # ensure hash only has the :churn key
+    def to_h
+      { churn: @churn[:churn] }
+    end
+
+    # @param args [Hash] churn metric run options
+    # @return [Hash] churn results
+    def run(args)
+      # @note passing in false to report will return a hash
+      #    instead of the default String
+      ::Churn::ChurnCalculator.new(args).report(false)
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+class MetricFu::ChurnHotspot < MetricFu::Hotspot
+  COLUMNS = %w{times_changed}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :churn
+  end
+
+  def map_strategy
+    :present
+  end
+
+  def reduce_strategy
+    :sum
+  end
+
+  def score_strategy
+    :calculate_score
+  end
+
+  def calculate_score(metric_ranking, item)
+    flat_churn_score = 0.50
+    metric_ranking.scored?(item) ? flat_churn_score : 0
+  end
+
+  def generate_records(data, table)
+    return if data == nil
+    Array(data[:changes]).each do |change|
+      table << {
+        "metric" => :churn,
+        "times_changed" => change[:times_changed],
+        "file_path" => change[:file_path]
+      }
+    end
+  end
+
+  def present_group(group)
+    "detected high level of churn (changed #{group[0].times_changed} times)"
+  end
+end

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

@@ -0,0 +1,29 @@
+module MetricFu
+  class MetricChurn < Metric
+    def name
+      :churn
+    end
+
+    def default_run_options
+      {
+        start_date: '"1 year ago"',
+        minimum_churn_count: 10,
+        ignore_files: [],
+        data_directory: MetricFu::Io::FileSystem.scratch_directory(name)
+      }
+    end
+
+    def has_graph?
+      false
+    end
+
+    def enable
+      super
+    end
+
+    def activate
+      activate_library("churn/calculator")
+      super
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+<h3>Source Control Churn Results</h3>
+<p>Files that change a lot in your project may be bad a sign.
+  This task uses your source control log to identify those files.
+  </p>
+<table>
+  <tr>
+    <th>File Path</th>
+    <th>Times Changed</th>
+  </tr>
+  <% count = 0 %>
+  <% if @churn[:changes] %>
+    <% @churn[:changes].each do |change| %>
+      <tr>
+        <td><%= link_to_filename(change[:file_path]) %></td>
+        <td><%= change[:times_changed] %></td>
+      </tr>
+      <% count += 1 %>
+    <% end %>
+  <% end %>
+</table>
+
+<% if @churn[:class_churn] %>
+<p>Classes that change a lot in your project may be bad a sign.</p>
+<table>
+  <tr>
+    <th>File Path</th>
+    <th>Times Changed</th>
+  </tr>
+  <% count = 0 %>
+  <% @churn[:class_churn].each do |change| %>
+    <tr>
+      <td><%= link_to_filename(change['klass']['file']) %> <%= change['klass']['klass'] %></td>
+      <td><%= change['times_changed'] %></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+<% end %>
+
+<% if @churn[:method_churn] %>
+<p>Methods that change a lot in your project may be bad a sign.</p>
+<table>
+  <tr>
+    <th>File Path</th>
+    <th>Times Changed</th>
+  </tr>
+  <% count = 0 %>
+  <% @churn[:method_churn].each do |change| %>
+    <tr>
+      <td><%= link_to_filename(change['method']['file']) %> <%= change['method']['method'] %></td>
+      <td><%= change['times_changed'] %></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+<% end %>
+
+<%= render_partial 'report_footer' %>

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

@@ -0,0 +1,51 @@
+module MetricFu
+  class FlayGenerator < Generator
+    def self.metric
+      :flay
+    end
+
+    def emit
+      args =  "#{minimum_duplication_mass} #{dirs_to_flay}"
+      @output = run!(args)
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n\n").map { |m| m.split("\n  ") }
+    end
+
+    def to_h
+      { flay: calculate_result(@matches) }
+    end
+
+    # TODO: move into analyze method
+    def calculate_result(matches)
+      total_score = matches.shift.first.split("=").last.strip
+      target = []
+      matches.each do |problem|
+        reason = problem.shift.strip
+        lines_info = problem.map do |full_line|
+          name, line = full_line.split(":").map(&:strip)
+          { name: name, line: line }
+        end
+        target << [reason: reason, matches: lines_info]
+      end
+      {
+        total_score: total_score,
+        matches: target.flatten
+      }
+    end
+
+    private
+
+    def minimum_duplication_mass
+      flay_mass = options[:minimum_score]
+      return "" unless flay_mass
+
+      "--mass #{flay_mass} "
+    end
+
+    def dirs_to_flay
+      options[:dirs_to_flay].join(" ")
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+MetricFu.reporting_require { "graphs/grapher" }
+module MetricFu
+  class FlayGrapher < Grapher
+    attr_accessor :flay_score, :labels
+
+    def self.metric
+      :flay
+    end
+
+    def initialize
+      super
+      @flay_score = []
+      @labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:flay]
+        @flay_score.push(metrics[:flay][:total_score].to_i)
+        @labels.update(@labels.size => date)
+      end
+    end
+
+    def title
+      "Flay: duplication"
+    end
+
+    def data
+      [
+        ["flay", @flay_score.join(",")]
+      ]
+    end
+
+    def output_filename
+      "flay.js"
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+class MetricFu::FlayHotspot < MetricFu::Hotspot
+  COLUMNS = %w{flay_reason flay_matching_reason}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :flay
+  end
+
+  def map_strategy
+    :present
+  end
+
+  def reduce_strategy
+    :sum
+  end
+
+  def score_strategy
+    :percentile
+  end
+
+  def generate_records(data, table)
+    return if data == nil
+    Array(data[:matches]).each do |match|
+      problems  = match[:reason]
+      matching_reason = problems.gsub(/^[0-9]+\) /, "").gsub(/\:[0-9]+/, "")
+      files     = []
+      locations = []
+      match[:matches].each do |file_match|
+        file_path = file_match[:name].sub(%r{^/}, "")
+        locations << "#{file_path}:#{file_match[:line]}"
+        files     << file_path
+      end
+      files = files.uniq
+      files.each do |file|
+        table << {
+          "metric" => name,
+          "file_path" => file,
+          "flay_reason" => problems + " files: #{locations.join(', ')}",
+          "flay_matching_reason" => matching_reason
+        }
+      end
+    end
+  end
+
+  def present_group(group)
+    occurences = group.size
+    "found #{occurences} code duplications"
+  end
+end

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