fastruby-metric_fu 5.0.0

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,40 @@
+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
+      @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

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

@@ -0,0 +1,39 @@
+class MetricFu::RoodiHotspot < MetricFu::Hotspot
+  COLUMNS = %w{problems}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :roodi
+  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[:problems]).each do |problem|
+      table << {
+        "metric" => name,
+        "problems" => problem[:problem],
+        "file_path" => problem[:file]
+      }
+    end
+  end
+
+  def present_group(group)
+    occurences = group.size
+    "found #{occurences} design problems"
+  end
+end

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

@@ -0,0 +1,24 @@
+module MetricFu
+  class MetricRoodi < Metric
+    def name
+      :roodi
+    end
+
+    def default_run_options
+      { dirs_to_roodi: MetricFu::Io::FileSystem.directory("code_dirs"),
+        roodi_config: "#{MetricFu::Io::FileSystem.directory('root_directory')}/config/roodi_config.yml" }
+    end
+
+    def has_graph?
+      true
+    end
+
+    def enable
+      super
+    end
+
+    def activate
+      super
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+<h3>Roodi Results</h3>
+
+<p><a href="http://roodi.rubyforge.org/">Roodi</a> parses your Ruby code and warns you about design issues you have based on the checks that is has configured.</p>
+
+<%= render_partial 'graph', {:graph_name => 'roodi'} %>
+
+<table>
+  <tr>
+    <th>File Path</th>
+    <th>Warning</th>
+  </tr>
+  <% count = 0 %>
+  <% @roodi[:problems].each do |problem| %>
+    <tr class='<%= cycle("light", "dark", count) %>'>
+      <td><%= link_to_filename(problem[:file], problem[:line]) %></td>
+      <td><%= problem[:problem] %></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+
+<%= render_partial 'report_footer' %>

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

@@ -0,0 +1,145 @@
+# encoding: utf-8
+MetricFu.lib_require       { "utility"                 }
+MetricFu.metrics_require   { "saikuro/scratch_file"    }
+MetricFu.metrics_require   { "saikuro/parsing_element" }
+MetricFu.data_structures_require { "line_numbers" }
+module MetricFu
+  class SaikuroGenerator < MetricFu::Generator
+    def self.metric
+      :saikuro
+    end
+
+    def emit
+      options_string = options.inject("") do |options, option|
+        option[0] == :input_directory ? options : options + "--#{option.join(' ')} "
+      end
+
+      options[:input_directory].each do |input_dir|
+        options_string += "--input_directory #{input_dir} "
+      end
+
+      @output = run!(options_string)
+    end
+
+    def analyze
+      @files = sort_files(assemble_files)
+      @classes = sort_classes(assemble_classes(@files))
+      @meths = sort_methods(assemble_methods(@files))
+    end
+
+    def to_h
+      @saikuro_data = {
+        files:    files_with_relative_paths(@files),
+        classes:  @classes.map(&:to_h),
+        methods:  @meths.map(&:to_h),
+      }
+      clear_scratch_files!
+      { saikuro: @saikuro_data }
+    end
+
+    def per_file_info(out)
+      @saikuro_data[:files].each do |file_data|
+        filename = file_data[:filename]
+        next if erb_file?(filename) || file_not_exists?(filename)
+        next unless line_numbers = line_numbers_from_file(filename)
+
+        build_output_from_line_numbers(out, line_numbers, file_data)
+      end
+    end
+
+    def build_output_from_line_numbers(out, line_numbers, file_data)
+      filename = file_data[:filename]
+      output = out[filename]
+      method_data_for_file_data(file_data) do |method_data|
+        line = line_numbers.start_line_for_method(method_data[:name]).to_s
+        result = {
+          type: :saikuro,
+          description: "Complexity #{method_data[:complexity]}"
+        }
+        output[line] <<  result
+      end
+      out
+    end
+
+    def line_numbers_from_file(filename)
+      MetricFu::LineNumbers.new(File.read(filename))
+    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 Saikuro information for this file."
+    end
+
+    def method_data_for_file_data(file_data, &_block)
+      return unless block_given?
+      file_data[:classes].each do |class_data|
+        class_data[:methods].each do |method_data|
+          yield method_data
+        end
+      end
+    end
+
+    private
+
+    def erb_file?(filename)
+      File.extname(filename) == ".erb"
+    end
+
+    def file_not_exists?(filename)
+      !File.exists?(filename)
+    end
+
+    def sort_methods(methods)
+      methods.sort_by { |method| method.complexity.to_i }.reverse
+    end
+
+    def assemble_methods(files)
+      methods = []
+      files.each do |file|
+        file.elements.each do |element|
+          element.defs.each do |defn|
+            defn.name = "#{element.name}##{defn.name}"
+            methods << defn
+          end
+        end
+      end
+      methods
+    end
+
+    def sort_classes(classes)
+      classes.sort_by { |k| k.complexity.to_i }.reverse
+    end
+
+    def assemble_classes(files)
+      files.map(&:elements).flatten
+    end
+
+    def sort_files(files)
+      files.sort_by do |file|
+        file.elements.
+          max { |a, b| a.complexity.to_i <=> b.complexity.to_i }.
+          complexity.to_i
+      end.reverse
+    end
+
+    def assemble_files
+      SaikuroScratchFile.assemble_files(Dir.glob("#{metric_directory}/**/*.html"))
+    end
+
+    def files_with_relative_paths(files)
+      files.map do |file|
+        file_hash = file.to_h
+        file_hash[:filename] = file_relative_path(file)
+        file_hash
+      end.to_a
+    end
+
+    def file_relative_path(file)
+      filepath = file.filepath
+      path = filepath.gsub(/^#{metric_directory}\//, "")
+      "#{path}/#{file.filename}"
+    end
+
+    def clear_scratch_files!
+      MetricFu::Utility.rm_rf(metric_directory)
+    end
+  end
+end