code_metric_fu 4.14.0

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

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

@@ -0,0 +1,61 @@
+require "yaml"
+MetricFu.metrics_require do
+  [
+    "hotspots/hotspot",
+    "hotspots/analysis/analyzer_tables",
+    "hotspots/analysis/analyzed_problems",
+    "hotspots/analysis/rankings"
+  ]
+end
+
+module MetricFu
+  class HotspotAnalyzer
+    COMMON_COLUMNS = %w{metric}
+    GRANULARITIES =  %w{file_path class_name method_name}
+
+    def tool_analyzers
+      MetricFu::Hotspot.analyzers
+    end
+
+    def initialize(result_hash)
+      # we can't depend on the result
+      # returning a parsed yaml file as a hash?
+      result_hash = YAML::load(result_hash) if result_hash.is_a?(String)
+      setup(result_hash)
+    end
+
+    def hotspots
+      analyzed_problems.worst_items
+    end
+
+    def analyzed_problems
+      @analyzed_problems = MetricFu::HotspotAnalyzedProblems.new(@rankings, @analyzer_tables)
+    end
+
+    private
+
+    # TODO clarify each of these steps in setup
+    # extract into its own method
+    # remove unnecessary constants,
+    # turn into methods
+    def setup(result_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(&: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(result_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)
+      # TODO does it not need to return something here?
+      analyzed_problems
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module MetricFu
+  class MetricHotspots < Metric
+    def name
+      :hotspots
+    end
+
+    # TODO remove explicit Churn dependency
+    def default_run_options
+      { start_date: "1 year ago", minimum_churn_count: 10 }
+    end
+
+    def has_graph?
+      false
+    end
+
+    def enable
+      super
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+<h3>Hotspot Results</h3>
+<p>Meta analysis of your metrics to find hotspots in your code.</p>
+<br/>
+
+<% if @hotspots.nil? || @hotspots.size.zero? %>
+  No Hotspots were found.
+<% else %>
+
+  <% granularities = %w[files classes methods] %>
+  <table>
+    <tr valign="top">
+    <% granularities.each do |granularity| %>
+       <th width='33%'>
+    <%= granularity.to_s.capitalize %></th>
+    <% end %>
+    </tr>
+
+    <% hotspots = [] %>
+    <% granularities.each_index do |index| %>
+      <% granularity = granularities[index] %>
+      <% hotspots << @hotspots[granularity] %>
+    <% end %>
+
+    <% hotspots_length = 0 %>
+    <% columns = [0, 1, 2] %>
+    <% while (hotspots_length < hotspots[0].length || hotspots_length < hotspots[1].length || hotspots_length < hotspots[2].length) do %>
+      <tr  valign="top">
+        <% columns.each do |column| %>
+          <% item = hotspots[column].length >= hotspots_length ? hotspots[column][hotspots_length] : nil %>
+          <% if item %>
+            <% location = item.fetch('location') %>
+            <% file, line =  location.fetch('file_name'), location.fetch('line_number') %>
+            <td>
+            <b>
+              <%= display_location(location) %>
+            </b>
+            <% unless per_file_data[file].empty? %>
+              <small>&laquo;
+                <b><a href="<%= html_filename(file) %><%= (line.nil? ? '' : "#line#{line}") %>">annotate</a></b>
+               &raquo;</small>
+            <% end %>
+            <br/><br/>
+            <!-- TODO HOTSPOTS for metric fu nice metric_link method -->
+            <% item.fetch('details').each do |metric, info| %>
+              <%#= metric_link(@stat, metric, h(metric.to_s.capitalize)) + ": " + h(info)%><br/>
+              <%= "#{metric.to_s.capitalize}: #{info}" %><br/>
+            <% end %>
+            </td>
+          <% else %>
+          <td> &nbsp; </td>
+          <% end %>
+        <% end %>
+        <% hotspots_length += 1 %>
+      </tr>
+    <% end %>
+
+  </table>
+<% end %>
+
+<%= render_partial 'report_footer' %>

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

@@ -0,0 +1,47 @@
+module MetricFu
+  class RailsBestPracticesGenerator < Generator
+    def self.metric
+      :rails_best_practices
+    end
+
+    def initialize(options = {})
+      super(MetricFu::Utility.stringify_keys(options))
+    end
+
+    def emit
+      mf_debug "** Rails Best Practices"
+      path = "."
+      analyzer = ::RailsBestPractices::Analyzer.new(path, options)
+      analyzer.analyze
+      @output = analyzer.errors
+    end
+
+    def analyze
+      @problems = @output.collect do |problem|
+        {
+          file: problem.short_filename,
+          line: problem.line_number,
+          problem: problem.message,
+          url: problem.url
+        }
+      end
+      total = ["Found #{@problems.count} errors."]
+      @rails_best_practices_results = { total: total, problems: @problems }
+    end
+
+    def to_h
+      { rails_best_practices: @rails_best_practices_results }
+    end
+
+    def per_file_info(out)
+      @rails_best_practices_results[:problems].each do |problem|
+        next if problem[:file] == "" || problem[:problem].nil?
+
+        lines = problem[:line].split(/\s*,\s*/)
+        lines.each do |line|
+          out[problem[:file]][line] << { type: :rails_best_practices, description: problem[:problem] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+MetricFu.reporting_require { "graphs/grapher" }
+module MetricFu
+  class RailsBestPracticesGrapher < Grapher
+    attr_accessor :rails_best_practices_count, :labels
+
+    def self.metric
+      :rails_best_practices
+    end
+
+    def initialize
+      super
+      @rails_best_practices_count = []
+      @labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:rails_best_practices]
+        size = (metrics[:rails_best_practices][:problems] || []).size
+        @rails_best_practices_count.push(size)
+        @labels.update(@labels.size => date)
+      end
+    end
+
+    def title
+      "Rails Best Practices: design problems"
+    end
+
+    def data
+      [
+        ["rails_best_practices", @rails_best_practices_count.join(",")]
+      ]
+    end
+
+    def output_filename
+      "rails_best_practices.js"
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module MetricFu
+  class MetricRailsBestPractices < Metric
+    def name
+      :rails_best_practices
+    end
+
+    def default_run_options
+      {
+        silent: true,
+        exclude: []
+      }
+    end
+
+    def has_graph?
+      true
+    end
+
+    def enable
+      if MetricFu.configuration.supports_ripper?
+        super if MetricFu.configuration.rails?
+      else
+        MetricFu.logger.debug("Rails Best Practices is only available in MRI 1.9. It requires ripper")
+      end
+    end
+
+    def activate
+      activate_library("rails_best_practices")
+      super
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+<h3>Rails Best Practices Results</h3>
+
+<p><a href="http://github.com/railsbp/rails_best_practices">rails_best_practices</a> is a code metric tool for rails projects.</p>
+
+<%= render_partial 'graph', {:graph_name => 'rails_best_practices'} %>
+
+<table>
+  <tr>
+    <th>File Path</th>
+    <th>Warning</th>
+  </tr>
+  <% count = 0 %>
+  <% @rails_best_practices[:problems].each do |problem| %>
+    <tr class='<%= cycle("light", "dark", count) %>'>
+      <td><%= link_to_filename(problem[:file], problem[:line]) %></td>
+      <td><a href =<%= problem[:url] %>><%= problem[:problem] %></a></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+
+<%= render_partial 'report_footer' %>

data/lib/metric_fu/metrics/rcov/external_client.rb

@@ -0,0 +1,22 @@
+# Reads and writes external coverage files as BINARY
+module MetricFu
+  class RCovTestCoverageClient
+    def initialize(coverage_file)
+      @file_path = Pathname(coverage_file)
+      @file_path.dirname.mkpath
+    end
+
+    def post_results(payload)
+      mf_log "Saving coverage payload to #{@file_path}"
+      dump(payload)
+    end
+
+    def load
+      File.binread(@file_path)
+    end
+
+    def dump(payload)
+      File.open(@file_path, "wb") { |file| file.write(payload) }
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+MetricFu.lib_require { "utility" }
+MetricFu.lib_require { "calculate" }
+MetricFu.data_structures_require { "line_numbers" }
+require_relative "rcov_format_coverage"
+require_relative "rcov_line"
+require_relative "external_client"
+
+module MetricFu
+  class RcovGenerator < MetricFu::Generator
+    def self.metric
+      :rcov
+    end
+
+    def emit
+      if run_rcov?
+        mf_debug "** Running the specs/tests in the [#{options[:environment]}] environment"
+        mf_debug "** #{command}"
+        `#{command}`
+      end
+    end
+
+    def command
+      @command ||= default_command
+    end
+
+    def command=(command)
+      @command = command
+    end
+
+    def reset_output_location
+      MetricFu::Utility.rm_rf(metric_directory, verbose: false)
+      MetricFu::Utility.mkdir_p(metric_directory)
+    end
+
+    def default_command
+      require "rake"
+      reset_output_location
+      test_files = FileList[*options[:test_files]].join(" ")
+      rcov_opts = options[:rcov_opts].join(" ")
+      %(RAILS_ENV=#{options[:environment]} rcov #{test_files} #{rcov_opts} >> #{default_output_file})
+    end
+
+    def analyze
+      rcov_text = load_output
+      formatter = MetricFu::RCovFormatCoverage.new(rcov_text)
+      @rcov = formatter.to_h
+    end
+
+    def to_h
+      {
+        rcov: @rcov
+      }
+    end
+
+    private
+
+    # We never run rcov anymore
+    def run_rcov?
+      false
+    end
+
+    def load_output
+      MetricFu::RCovTestCoverageClient.new(output_file).load
+    end
+
+    def output_file
+      options.fetch(:external)
+    end
+
+    # Only used if run_rcov? is true
+    def default_output_file
+      output_file || File.join(metric_directory, "rcov.txt")
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+MetricFu.reporting_require { "graphs/grapher" }
+module MetricFu
+  class RcovGrapher < Grapher
+    attr_accessor :rcov_percent, :labels
+
+    def self.metric
+      :rcov
+    end
+
+    def initialize
+      super
+      self.rcov_percent = []
+      self.labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:rcov]
+        rcov_percent.push(metrics[:rcov][:global_percent_run])
+        labels.update(labels.size => date)
+      end
+    end
+
+    def title
+      "Rcov: code coverage"
+    end
+
+    def data
+      [
+        ["rcov", @rcov_percent.join(",")]
+      ]
+    end
+
+    def output_filename
+      "rcov.js"
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+class MetricFu::RcovHotspot < MetricFu::Hotspot
+  COLUMNS = %w{percentage_uncovered}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :rcov
+  end
+
+  def map_strategy
+    :percentage_uncovered
+  end
+
+  def reduce_strategy
+    :average
+  end
+
+  def score_strategy
+    :identity
+  end
+
+  def generate_records(data, table)
+    return if data == nil
+    data.each do |file_name, info|
+      next if (file_name == :global_percent_run) || (info[:methods].nil?)
+      info[:methods].each do |method_name, percentage_uncovered|
+        location = MetricFu::Location.for(method_name)
+        table << {
+          "metric" => :rcov,
+          "file_path" => file_name,
+          "class_name" => location.class_name,
+          "method_name" => location.method_name,
+          "percentage_uncovered" => percentage_uncovered
+        }
+      end
+    end
+  end
+
+  def present_group(group)
+    occurences = group.size
+    average_code_uncoverage = get_mean(group.column("percentage_uncovered"))
+    "#{'average ' if occurences > 1}uncovered code is %.1f%" % average_code_uncoverage
+  end
+end

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

@@ -0,0 +1,61 @@
+module MetricFu
+  class MetricRcov < Metric
+    def name
+      :rcov
+    end
+
+    def default_run_options
+      {
+        environment: "test",
+        test_files: Dir["{spec,test}/**/*_{spec,test}.rb"],
+        rcov_opts: rcov_opts,
+        external: nil,
+      }
+    end
+
+    def coverage_file=(coverage_file)
+      configured_run_options.update(external: coverage_file)
+    end
+
+    def has_graph?
+      true
+    end
+
+    def enable
+      if external_coverage_file?
+        super
+      else
+        mf_debug("RCov is not available. See README")
+      end
+    end
+
+    def activate
+      super
+    end
+
+    def external_coverage_file?
+      if coverage_file = run_options[:external]
+        File.exist?(coverage_file) ||
+          mf_log("Configured RCov file #{coverage_file.inspect} does not exist")
+      else
+        false
+      end
+    end
+
+    private
+
+    def rcov_opts
+      rcov_opts = [
+        "--sort coverage",
+        "--no-html",
+        "--text-coverage",
+        "--no-color",
+        "--profile",
+        "--exclude-only '.*'",
+        '--include-file "\Aapp,\Alib"'
+      ]
+      rcov_opts << "-Ispec" if File.exist?("spec")
+      rcov_opts
+    end
+  end
+end