fastruby-metric_fu 5.0.0

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