code_metric_fu 4.14.0

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

@@ -0,0 +1,149 @@
+module MetricFu
+  class RCovFormatCoverage
+    NEW_FILE_MARKER = /^={80}$/.freeze
+
+    def initialize(rcov_text)
+      fail "no rcov text" if rcov_text.nil?
+      @rcov_text = rcov_text
+    end
+
+    def to_h
+      rcov_text = @rcov_text.split(NEW_FILE_MARKER)
+
+      rcov_text.shift # Throw away the first entry - it's the execution time etc.
+
+      files = assemble_files(rcov_text)
+
+      TestCoverage.new(files).to_h
+    end
+
+    private
+
+    def assemble_files(rcov_text)
+      files = {}
+      rcov_text.each_slice(2) { |out| files[out.first.strip] = out.last }
+      files.each_pair { |fname, content| files[fname] = content.split("\n") }
+      files.each_pair do |fname, content|
+        content.map! do |raw_line|
+          covered_line = if raw_line.start_with?("--")
+                           nil # simplecov ignores some lines
+                         elsif raw_line.start_with?("!!")
+                           0
+                         else
+                           1
+                         end
+          RCovLine.new(raw_line[3..-1], covered_line).to_h
+        end
+        content.reject! { |line| line[:content].to_s == "" }
+        files[fname] = { lines: content }
+      end
+      files
+    end
+
+    class TestCoverage
+      def initialize(filename_content)
+        @files = filename_content
+        @global_total_lines = 0
+        @global_total_lines_run = 0
+      end
+
+      def to_h
+        @test_coverage ||= begin
+          add_coverage_percentage(@files)
+          add_method_data(@files)
+          add_global_percent_run(@files, @global_total_lines, @global_total_lines_run)
+          @files
+        end
+      end
+
+      def self.floating_percent(numerator, denominator)
+        (numerator * 100.0) / denominator.to_f
+      end
+
+      def self.integer_percent(numerator, denominator)
+        ::MetricFu::Calculate.integer_percent(numerator, denominator)
+      end
+
+      def self.percent_run(lines)
+        line_coverage = RCovLine.line_coverage(lines)
+        covered_lines = RCovLine.covered_lines(line_coverage)
+        ignored_lines = RCovLine.ignored_lines(line_coverage)
+        relevant_lines = lines.count - ignored_lines
+        if block_given?
+          yield covered_lines, relevant_lines
+        else
+          floating_percent(covered_lines, relevant_lines)
+        end
+      end
+
+      private
+
+      # TODO: remove multiple side effects
+      #   sets global ivars and
+      #   modifies the param passed in
+      def add_coverage_percentage(files)
+        files.each_pair do |fname, content|
+          lines = content[:lines]
+          percent_run =
+            self.class.percent_run(lines) do |covered, relevant|
+              @global_total_lines_run += covered
+              @global_total_lines += relevant
+              self.class.integer_percent(covered, relevant)
+            end
+          files[fname][:percent_run] = percent_run
+        end
+      end
+
+      def add_global_percent_run(test_coverage, total_lines, total_lines_run)
+        percentage = self.class.floating_percent(total_lines_run, total_lines)
+        test_coverage.update(
+          global_percent_run: round_to_tenths(percentage)
+        )
+      end
+
+      def add_method_data(test_coverage)
+        test_coverage.each_pair do |file_path, info|
+          file_contents = ""
+          coverage = []
+
+          info[:lines].each_with_index do |line, _index|
+            file_contents << "#{line[:content]}\n"
+            coverage << line[:was_run]
+          end
+
+          begin
+            line_numbers = MetricFu::LineNumbers.new(file_contents)
+          rescue StandardError => e
+            raise e unless e.message =~ /you shouldn't be able to get here/
+            mf_log "ruby_parser blew up while trying to parse #{file_path}. You won't have method level TestCoverage information for this file."
+            next
+          end
+
+          method_coverage_map = {}
+          coverage.each_with_index do |covered, index|
+            line_number = index + 1
+            if line_numbers.in_method?(line_number)
+              method_name = line_numbers.method_at_line(line_number)
+              method_coverage_map[method_name] ||= {}
+              method_coverage_map[method_name][:total] ||= 0
+              method_coverage_map[method_name][:total] += 1
+              method_coverage_map[method_name][:uncovered] ||= 0
+              method_coverage_map[method_name][:uncovered] += 1 if !covered
+            end
+          end
+
+          test_coverage[file_path][:methods] = {}
+
+          method_coverage_map.each do |method_name, coverage_data|
+            test_coverage[file_path][:methods][method_name] = (coverage_data[:uncovered] / coverage_data[:total].to_f) * 100.0
+          end
+        end
+      end
+
+      def round_to_tenths(decimal)
+        decimal = 0.0 if decimal.to_s.eql?("NaN")
+        (decimal * 10).round / 10.0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module MetricFu
+  class RCovLine
+    attr_accessor :content, :was_run
+
+    def initialize(content, was_run)
+      @content = content
+      @was_run = was_run
+    end
+
+    def to_h
+      { content: @content, was_run: @was_run }
+    end
+
+    def covered?
+      @was_run == 1
+    end
+
+    def missed?
+      @was_run == 0
+    end
+
+    def ignored?
+      @was_run.nil?
+    end
+
+    def self.line_coverage(lines)
+      lines.map { |line| line[:was_run] }
+    end
+
+    def self.covered_lines(line_coverage)
+      line_coverage.count(1)
+    end
+
+    def self.missed_lines(line_coverage)
+      line_coverage.count(0)
+    end
+
+    def self.ignored_lines(line_coverage)
+      line_coverage.count(nil)
+    end
+
+    def css_class
+      return "rcov_not_run" if missed?
+
+      "rcov_run"
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+<style data-file="rcov">
+<%=  inline_css("css/rcov.css") %>
+</style>
+<h3>Rcov Code Coverage Results</h3>
+
+<p>C0 code coverage information.</p>
+
+<%= render_partial 'graph', {:graph_name => 'rcov'} %>
+
+<p>Total Coverage: <%= @rcov.delete(:global_percent_run) %>% </p>
+<table>
+  <tr>
+    <th>File Path</th>
+    <th>Percent run</th>
+  </tr>
+  <% count = 0 %>
+  <% @rcov.sort_by{ |k,v| v[:percent_run] }.each do |fname, file| %>
+    <tr>
+      <td><a href="#<%= fname.gsub(/[^a-z]+/, '_') %>"><%= fname %></a></td>
+      <td><%= file[:percent_run] %></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+
+<% @rcov.sort_by{ |k,v| v[:percent_run] }.each do |fname, file| %>
+  <h2 id="<%= fname.gsub(/[^a-z]+/, '_') %>"> <%= fname %></h2>
+  <div class="rcov_overflow">
+    <table class="rcov_code">
+    <% file[:lines].each_with_index do |line, index| %>
+      <tr>
+        <% rcov_line = RCovLine.new(line[:content], line[:was_run]) %>
+        <td class="<%= rcov_line.css_class %>"><%= link_to_filename(fname, index + 1, "<pre>#{line[:content]}</pre>") %></td>
+      </tr>
+    <% end %>
+    </table>
+  </div>
+<% end %>
+
+<%= render_partial 'report_footer' %>

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

@@ -0,0 +1,74 @@
+if defined?(JRUBY_VERSION)
+  if ENV["JRUBY_OPTS"].to_s !~ /-Xcli.debug=true/
+    warn "Coverage may be inaccurate; Try setting JRUBY_OPTS=\"-Xcli.debug=true --debug\""
+    # see https://github.com/metricfu/metric_fu/pull/226
+    #     https://github.com/jruby/jruby/issues/1196
+    #     https://jira.codehaus.org/browse/JRUBY-6106
+    #     https://github.com/colszowka/simplecov/issues/86
+  end
+end
+require "simplecov"
+require "metric_fu/logger"
+require_relative "external_client"
+require_relative "rcov_format_coverage"
+
+class SimpleCov::Formatter::MetricFu
+  def format(result)
+    rcov_text = FormatLikeRCov.new(result).format
+    client = MetricFu::RCovTestCoverageClient.new(coverage_file_path)
+    client.post_results(rcov_text)
+  end
+
+  attr_writer :coverage_file_path
+
+  def coverage_file_path
+    @coverage_file_path || self.coverage_file_path = default_coverage_file_path
+  end
+
+  def default_coverage_file_path
+    File.join(SimpleCov.root, "coverage", "rcov", output_file_name)
+  end
+
+  # TODO: Read in from legacy coverage/rcov/rcov.txt path, when set
+  # write to date-specific report file, read from if present
+  # e.g.
+  #  MetricFu::Metric.get_metric(:rcov).run_options[:output_directory]
+  #  or
+  #  metric_directory = MetricFu::Io::FileSystem.scratch_directory('Ymd-coverage')
+  #  MetricFu::Utility.mkdir_p(metric_directory, :verbose => false)
+  # @note legacy file name is 'rcov.txt'
+  #   going forward, the file name will be in a date-stamped
+  #   format like for all other reported metrics.
+  def output_file_name
+    "rcov.txt"
+  end
+
+  # report should reference file used to build it
+  class FormatLikeRCov
+    def initialize(result)
+      @result = result
+    end
+
+    def format
+      content = "metric_fu shift the first line\n"
+      @result.source_files.each do |source_file|
+        content << "=" * 80
+        content << "\n #{simple_file_name(source_file)}\n"
+        content << "=" * 80
+        content << "\n"
+        source_file.lines.each do |line|
+          content << "!!" if line.missed?
+          content << "--" if line.never? || line.skipped?
+          content << "  " if line.covered?
+          content << " #{line.src.chomp}\n"
+        end
+        content << "\n"
+      end
+      content
+    end
+
+    def simple_file_name(source_file)
+      source_file.filename.gsub(SimpleCov.root, ".")
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module MetricFu
+  class ReekGenerator < Generator
+    def self.metric
+      :reek
+    end
+
+    def emit
+      files = files_to_analyze
+      if files.empty?
+        mf_log "Skipping Reek, no files found to analyze"
+        @output = run!([], config_files)
+      else
+        @output = run!(files, config_files)
+      end
+    end
+
+    def run!(files, config_files)
+      smells = []
+      files.each do |file|
+        e = examiner.new(File.new(file))
+        smells += e.smells
+      end
+      smells
+    end
+
+    def analyze
+      @matches = @output.group_by(&:source).collect do |file_path, smells|
+        { file_path: file_path,
+          code_smells: analyze_smells(smells) }
+      end
+    end
+
+    def to_h
+      { reek: { matches: @matches } }
+    end
+
+    def per_file_info(out)
+      @matches.each do |file_data|
+        file_path = file_data[:file_path]
+        next if File.extname(file_path) =~ /\.erb|\.html|\.haml/
+        begin
+          line_numbers = MetricFu::LineNumbers.new(File.read(file_path), file_path)
+        rescue StandardError => e
+          raise e unless e.message =~ /you shouldn't be able to get here/
+          mf_log "ruby_parser blew up while trying to parse #{file_path}. You won't have method level reek information for this file."
+          next
+        end
+
+        file_data[:code_smells].each do |smell_data|
+          line = line_numbers.start_line_for_method(smell_data[:method])
+          out[file_data[:file_path]][line.to_s] << { type: :reek,
+                                                     description: "#{smell_data[:type]} - #{smell_data[:message]}" }
+        end
+      end
+    end
+
+    private
+
+    def files_to_analyze
+      dirs_to_reek = options[:dirs_to_reek]
+      files_to_reek = dirs_to_reek.map { |dir| Dir[File.join(dir, "**", "*.rb")] }.flatten
+      remove_excluded_files(files_to_reek)
+    end
+
+    # TODO: Check that specified line config file exists
+    def config_files
+      Array(options[:config_file_pattern])
+    end
+
+    def analyze_smells(smells)
+      smells.collect(&method(:smell_data))
+    end
+
+    def smell_data(smell)
+      { method: smell.context,
+        message: smell.message,
+        type: smell_type(smell),
+        lines: smell.lines }
+    end
+
+    def smell_type(smell)
+      return smell.subclass if smell.respond_to?(:subclass)
+
+      smell.smell_type
+    end
+
+    def examiner
+      require "reek"
+      # To load any changing dependencies such as "reek/configuration/app_configuration"
+      #   Added in 1.6.0 https://github.com/troessner/reek/commit/7f4ed2be442ca926e08ccc41945e909e8f710947
+      #   But not always loaded
+      require "reek/cli/application"
+
+      Reek.const_defined?(:Examiner) ? Reek.const_get(:Examiner) : Reek.const_get(:Core).const_get(:Examiner)
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+MetricFu.reporting_require { "graphs/grapher" }
+module MetricFu
+  class ReekGrapher < Grapher
+    attr_accessor :reek_count, :labels
+
+    def self.metric
+      :reek
+    end
+
+    def initialize
+      super
+      @reek_count = {}
+      @labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:reek]
+        counter = @labels.size
+        @labels.update(@labels.size => date)
+
+        metrics[:reek][:matches].each do |reek_chunk|
+          reek_chunk[:code_smells].each do |code_smell|
+            # speaking of code smell...
+            @reek_count[code_smell[:type]] = [] if @reek_count[code_smell[:type]].nil?
+            if @reek_count[code_smell[:type]][counter].nil?
+              @reek_count[code_smell[:type]][counter] = 1
+            else
+              @reek_count[code_smell[:type]][counter] += 1
+            end
+          end
+        end
+      end
+    end
+
+    def title
+      "Reek: code smells"
+    end
+
+    def data
+      @reek_count.map do |name, count|
+        [name, nil_counts_to_zero(count).join(",")]
+      end
+    end
+
+    def output_filename
+      "reek.js"
+    end
+
+    private
+
+    def nil_counts_to_zero(counts)
+      counts.map { |count| count || 0 }
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# coding: utf-8
+class MetricFu::ReekHotspot < MetricFu::Hotspot
+  # Note that in practice, the prefix reek__ is appended to each one
+  # This was a partially implemented idea to avoid column name collisions
+  # but it is only done in the ReekHotspot
+  COLUMNS = %w{type_name message value value_description comparable_message}
+
+  def columns
+    COLUMNS.map { |column| "#{name}__#{column}" }
+  end
+
+  def name
+    :reek
+  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
+    data[:matches].each do |match|
+      file_path = match[:file_path]
+      match[:code_smells].each do |smell|
+        location = MetricFu::Location.for(smell[:method])
+        smell_type = smell[:type]
+        message = smell[:message]
+        table << {
+          "metric" => name, # important
+          "file_path" => file_path, # important
+          # NOTE: ReekHotspot is currently different than other hotspots with regard
+          # to column name. Note the COLUMNS constant and #columns method
+          "reek__message" => message,
+          "reek__type_name" => smell_type,
+          "reek__value" => parse_value(message),
+          "reek__value_description" => build_value_description(smell_type, message),
+          "reek__comparable_message" => comparable_message(smell_type, message),
+          "class_name" => location.class_name, # important
+          "method_name" => location.method_name, # important
+        }
+      end
+    end
+  end
+
+  def self.numeric_smell?(type)
+    ["Large Class", "Long Method", "Long Parameter List"].include?(type)
+  end
+
+  def present_group(group)
+    occurences = group.size
+    "found #{occurences} code smells"
+  end
+
+  private
+
+  def comparable_message(type_name, message)
+    if self.class.numeric_smell?(type_name)
+      match = message.match(/\d+/)
+      if match
+        match.pre_match + match.post_match
+      else
+        message
+      end
+    else
+      message
+    end
+  end
+
+  def build_value_description(type_name, message)
+    item_type = message.match(/\d+ (.*)$/)
+    if item_type
+      "number of #{item_type[1]} in #{type_name.downcase}"
+    else
+      nil
+    end
+  end
+
+  def parse_value(message)
+    # mf_debug "parsing #{message}"
+    match = message.match(/\d+/)
+    if match
+      match[0].to_i
+    else
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module MetricFu
+  class MetricReek < Metric
+    def name
+      :reek
+    end
+
+    def default_run_options
+      {
+        dirs_to_reek: MetricFu::Io::FileSystem.directory("code_dirs"),
+        config_file_pattern: nil,
+      }
+    end
+
+    def has_graph?
+      true
+    end
+
+    def enable
+      super
+    end
+
+    def activate
+      super
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+<h3>Reek Results</h3>
+
+<p><a href="http://github.com/troessner/reek">Reek</a> detects common code smells in ruby code.</p>
+
+<%= render_partial 'graph', {:graph_name => 'reek'} %>
+
+<table>
+  <tr>
+    <th>File Path</th>
+    <th>Method</th>
+    <th>Description</th>
+    <th>Type</th>
+  </tr>
+  <% count = 0 %>
+  <% @reek[:matches].each do |match| %>
+    <% match[:code_smells].each do |smell| %>
+      <tr class='<%= cycle("light", "dark", count) %>'>
+        <td><%= link_to_filename(match[:file_path]) %></td>
+        <td>
+          <%= smell[:method] %>
+        </td>
+        <td>
+          <%= smell[:message] %>
+        </td>
+        <td>
+          <%= smell[:type] %>
+        </td>
+      </tr>
+      <% count += 1 %>
+    <% end %>
+  <% end %>
+
+</table>
+
+<%= render_partial 'report_footer' %>

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

@@ -0,0 +1,41 @@
+module MetricFu
+  class RoodiGenerator < Generator
+    def self.metric
+      :roodi
+    end
+
+    def emit
+      files_to_analyze = options[:dirs_to_roodi].map { |dir| Dir[File.join(dir, "**/*.rb")] }
+      files = remove_excluded_files(files_to_analyze.flatten)
+      config = options[:roodi_config] ? "-config=#{options[:roodi_config]}" : ""
+      args = "#{config} #{files.join(' ')}"
+      @output = run!(args)
+    end
+
+    def analyze
+      @output = MetricFu::Utility.strip_escape_codes(@output)
+      @matches = @output.chomp.split("\n").map { |m| m.split(" - ") }
+      total = @matches.pop
+      @matches.reject! { |array| array.size < 2 }
+      @matches.map! do |match|
+        file, line = match[0].split(":")
+        problem = match[1]
+        { file: file, line: line, problem: problem }
+      end
+      total << "Found #{@matches.size} errors."
+      @roodi_results = { total: total, problems: @matches }
+    end
+
+    def to_h
+      { roodi: @roodi_results }
+    end
+
+    def per_file_info(out)
+      @matches.each do |match|
+        out[match[:file]] ||= {}
+        out[match[:file]][match[:line]] ||= []
+        out[match[:file]][match[:line]] << { type: :roodi, description: match[:problem] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+MetricFu.reporting_require { "graphs/grapher" }
+module MetricFu
+  class RoodiGrapher < Grapher
+    attr_accessor :roodi_count, :labels
+
+    def self.metric
+      :roodi
+    end
+
+    def initialize
+      super
+      @roodi_count = []
+      @labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:roodi]
+        @roodi_count.push(metrics[:roodi][:problems].size)
+        @labels.update(@labels.size => date)
+      end
+    end
+
+    def title
+      "Roodi: design problems"
+    end
+
+    def data
+      [
+        ["roodi", @roodi_count.join(",")]
+      ]
+    end
+
+    def output_filename
+      "roodi.js"
+    end
+  end
+end