fastruby-metric_fu 5.0.0

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

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,94 @@
+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)
+      files.map do |file|
+        examiner.new(File.new(file), filter_by_smells: config_files)
+      end
+    end
+
+    def analyze
+      @matches = @output.flat_map(&:smells).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