code_metric_fu 4.14.0

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

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

@@ -0,0 +1,51 @@
+class MetricFu::SaikuroHotspot < MetricFu::Hotspot
+  COLUMNS = %w{lines complexity}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :saikuro
+  end
+
+  def map_strategy
+    :complexity
+  end
+
+  def reduce_strategy
+    :average
+  end
+
+  def score_strategy
+    :identity
+  end
+
+  def generate_records(data, table)
+    return if data == nil
+    data[:files].each do |file|
+      file_name = file[:filename]
+      file[:classes].each do |klass|
+        location = MetricFu::Location.for(klass[:class_name])
+        offending_class = location.class_name
+        klass[:methods].each do |match|
+          offending_method = MetricFu::Location.for(match[:name]).method_name
+          table << {
+            "metric" => name,
+            "lines" => match[:lines],
+            "complexity" => match[:complexity],
+            "class_name" => offending_class,
+            "method_name" => offending_method,
+            "file_path" => file_name,
+          }
+        end
+      end
+    end
+  end
+
+  def present_group(group)
+    occurences = group.size
+    complexity = get_mean(group.column("complexity"))
+    "#{'average ' if occurences > 1}complexity is %.1f" % complexity
+  end
+end

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

@@ -0,0 +1,31 @@
+module MetricFu
+  class MetricSaikuro < Metric
+    def name
+      :saikuro
+    end
+
+    def default_run_options
+      {
+        output_directory: MetricFu::Io::FileSystem.scratch_directory(name),
+        input_directory: MetricFu::Io::FileSystem.directory("code_dirs"),
+        cyclo: "",
+        filter_cyclo: "0",
+        warn_cyclo: "5",
+        error_cyclo: "7",
+        formater: "text",
+      }
+    end
+
+    def has_graph?
+      false
+    end
+
+    def enable
+      super
+    end
+
+    def activate
+      super
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module MetricFu
+  class SaikuroParsingElement
+    TYPE_REGEX = /Type:(.*) Name/
+    NAME_REGEX = /Name:(.*) Complexity/
+    COMPLEXITY_REGEX = /Complexity:(.*) Lines/
+    LINES_REGEX = /Lines:(.*)/
+
+    attr_reader :complexity, :lines, :defs, :element_type
+    attr_accessor :name
+
+    def initialize(line)
+      @line = line
+      @element_type = line.match(TYPE_REGEX)[1].strip
+      @name = line.match(NAME_REGEX)[1].strip
+      @complexity = line.match(COMPLEXITY_REGEX)[1].strip
+      @lines = line.match(LINES_REGEX)[1].strip
+      @defs = []
+    end
+
+    def <<(line)
+      @defs << MetricFu::SaikuroParsingElement.new(line)
+    end
+
+    def to_h
+      base = { name: @name, complexity: @complexity.to_i, lines: @lines.to_i }
+      unless @defs.empty?
+        defs = @defs.map do |my_def|
+          my_def = my_def.to_h
+          my_def.delete(:defs)
+          my_def
+        end
+        base[:defs] = defs
+      end
+      base
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+<h3>Saikuro Results</h3>
+<p><a href='http://saikuro.rubyforge.org/'>Saikuro</a> analyzes ruby code for cyclomatic complexity.</p>
+
+<h2>Analyzed Methods</h2>
+  <table>
+    <tr>
+      <th>Method Name</th>
+      <th>Complexity</th>
+      <th># Lines</th>
+    </tr>
+    <% @saikuro[:methods].each do |method| %>
+    <tr>
+      <td><%= method[:name] %></td>
+      <td><%= method[:complexity] %></td>
+      <td><%= method[:lines] %></td>
+    </tr>
+    <% end %>
+  </table>
+
+
+
+<h2>Analyzed Classes</h2>
+  <table>
+    <tr>
+      <th>Class Name</th>
+      <th>Complexity</th>
+      <th># Lines</th>
+    </tr>
+    <% @saikuro[:classes].each do |klass| %>
+    <tr>
+      <td><%= klass[:name] %></td>
+      <td><%= klass[:complexity] %></td>
+      <td><%= klass[:lines] %></td>
+    </tr>
+    <% end %>
+  </table>
+
+
+<h2>Analyzed Files</h2>
+<% @saikuro[:files].each do |file| %>
+  <% file[:classes].each do |klass| %>
+      <% if !klass[:methods].empty? %>
+        <h3><%=link_to_filename(file[:filename])%></h3>
+        <h4>Class : <%= klass[:class_name] %></h4>
+        <h5>Total complexity : <%= klass[:complexity] %></h5>
+        <h5>Total lines : <%= klass[:lines] %></h5>
+        <table>
+            <tr>
+              <th>Method</th>
+              <th>Complexity</th>
+              <th># Lines</th>
+            </tr>
+          <% klass[:methods].each do |method| %>
+            <tr>
+              <td>
+                <%= method[:name] %>
+              </td>
+              <td>
+                <%= method[:complexity] %>
+              </td>
+              <td>
+                <%= method[:lines]  %>
+              </td>
+            </tr>
+          <% end %>
+        </table>
+      <% end %>
+  <% end %>
+<% end %>
+
+<%= render_partial 'report_footer' %>

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

@@ -0,0 +1,108 @@
+MetricFu.metrics_require   { "saikuro/parsing_element" }
+module MetricFu
+  class SaikuroScratchFile
+    def self.assemble_files(glob)
+      files = []
+      glob.each do |path|
+        if is_valid_text_file?(path)
+          file = new(path)
+          if file
+            files << file
+          end
+        end
+      end
+      files
+    end
+
+    attr_reader :elements
+
+    def initialize(path)
+      @path = path
+      @elements = []
+      File.open(@path, "rb") do |file|
+        get_elements(file)
+      end
+    end
+
+    def self.is_valid_text_file?(path)
+      File.open(path, "rb") do |file|
+        if file.eof? || !file.readline.match(/--/)
+          return false
+        else
+          return true
+        end
+      end
+    end
+
+    def filename
+      File.basename(@path, "_cyclo.html")
+    end
+
+    def filepath
+      File.dirname(@path)
+    end
+
+    def to_h
+      merge_classes
+      { classes: @elements }
+    end
+
+    def get_elements(io)
+      while (line = io.readline)
+        return [] if line.nil? || line !~ /\S/
+        element ||= nil
+        if line.match(/START/)
+          unless element.nil?
+            @elements << element
+            element = nil
+          end
+          line = io.readline
+          element = MetricFu::SaikuroParsingElement.new(line)
+        elsif line.match(/END/)
+          @elements << element if element
+          element = nil
+        else
+          element << line if element
+        end
+      end
+    rescue EOFError
+      nil
+    end
+
+    def merge_classes
+      new_elements = []
+      get_class_names.each do |target_class|
+        elements = @elements.find_all { |el| el.name == target_class }
+        complexity = 0
+        lines = 0
+        defns = []
+        elements.each do |el|
+          complexity += el.complexity.to_i
+          lines += el.lines.to_i
+          defns << el.defs
+        end
+
+        new_element = { class_name: target_class,
+                        complexity: complexity,
+                        lines: lines,
+                        methods: defns.flatten.map(&:to_h) }
+        new_element[:methods] = new_element[:methods].
+                                sort_by { |x| x[:complexity] }.
+                                reverse
+
+        new_elements << new_element
+      end
+      @elements = new_elements if new_elements
+    end
+
+    def get_class_names
+      class_names = []
+      @elements.each do |element|
+        unless class_names.include?(element.name)
+          class_names << element.name
+        end
+      end
+      class_names
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module MetricFu
+  class StatsGenerator < Generator
+    def self.metric
+      :stats
+    end
+
+    def emit
+      require "code_metrics/statistics"
+      @output = MetricFu::Utility.capture_output do
+        CodeMetrics::Statistics.new(*dirs).to_s
+      end
+    end
+
+    def analyze
+      lines = remove_noise(@output).compact
+
+      @stats = {}
+
+      set_global_stats(lines.pop)
+      set_granular_stats(lines)
+
+      @stats
+    end
+
+    def to_h
+      { stats: @stats }
+    end
+
+    private
+
+    def remove_noise(output)
+      lines = output.split("\n")
+      lines = lines.find_all { |line| line =~ /^\s*[C|]/ }
+      lines.shift
+      lines
+    end
+
+    def set_global_stats(totals)
+      return if totals.nil?
+      parsed_totals = totals.split("  ").find_all { |el| !el.empty? }
+      @stats[:codeLOC] = parsed_totals.shift.match(/\d.*/)[0].to_i
+      @stats[:testLOC] = parsed_totals.shift.match(/\d.*/)[0].to_i
+      matched_numbers  = Array(parsed_totals.shift.match(/1\:(\d.*)/))
+      if matched_numbers.size == 2
+        @stats[:code_to_test_ratio] = matched_numbers[1].to_f
+      else
+        mf_log "Unexpected code to test ratio #{matched_numbers.inspect} over directories #{dirs.inspect}"
+        @stats[:code_to_test_ratio] = 0.0
+      end
+    end
+
+    def set_granular_stats(lines)
+      @stats[:lines] = lines.map do |line|
+        elements = line.split("|")
+        elements.map!(&:strip)
+        elements = elements.find_all { |el| !el.empty? }
+        info_line = {}
+        info_line[:name] = elements.shift
+        elements.map!(&:to_i)
+        [:lines, :loc, :classes, :methods,
+         :methods_per_class, :loc_per_method].each do |sym|
+          info_line[sym] = elements.shift
+        end
+        info_line
+      end
+    end
+
+    # @return [Array<[ 'Acceptance specs', 'spec/acceptance' ]>]
+    def dirs
+      require "code_metrics/stats_directories"
+      require "code_metrics/statistics"
+      stats_dirs = CodeMetrics::StatsDirectories.new
+      options.fetch(:additional_test_directories).each do |option|
+        stats_dirs.add_test_directories(option.fetch(:glob_pattern), option.fetch(:file_pattern))
+      end
+      options.fetch(:additional_app_directories).each do |option|
+        stats_dirs.add_directories(option.fetch(:glob_pattern), option.fetch(:file_pattern))
+      end
+      stats_dirs.directories
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+MetricFu.reporting_require { "graphs/grapher" }
+module MetricFu
+  class StatsGrapher < Grapher
+    attr_accessor :loc_counts, :lot_counts, :labels
+
+    def self.metric
+      :stats
+    end
+
+    def initialize
+      super
+      self.loc_counts = []
+      self.lot_counts = []
+      self.labels = {}
+    end
+
+    def get_metrics(metrics, date)
+      if metrics && metrics[:stats]
+        loc_counts.push(metrics[:stats][:codeLOC].to_i)
+        lot_counts.push(metrics[:stats][:testLOC].to_i)
+        labels.update(labels.size => date)
+      end
+    end
+
+    def title
+      "Stats: LOC & LOT"
+    end
+
+    def data
+      [
+        ["LOC", @loc_counts.join(",")],
+        ["LOT", @lot_counts.join(",")],
+      ]
+    end
+
+    def output_filename
+      "stats.js"
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+class MetricFu::StatsHotspot < MetricFu::Hotspot
+  COLUMNS = %w{stat_name stat_value}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :stats
+  end
+
+  def map_strategy
+    :absent
+  end
+
+  def reduce_strategy
+    :absent
+  end
+
+  def score_strategy
+    :absent
+  end
+
+  def generate_records(data, table)
+    return if data == nil
+    data.each do |key, value|
+      next if value.is_a?(Array)
+      table << {
+        "metric" => name,
+        "stat_name" => key,
+        "stat_value" => value
+      }
+    end
+  end
+end