rferraz-metric_fu 2.1.1

data/lib/base/report.rb

@@ -0,0 +1,108 @@
+module MetricFu
+
+  # MetricFu.report memoizes access to a Report object, that will be
+  # used throughout the lifecycle of the MetricFu app.
+  def self.report
+    @report ||= Report.new
+  end
+
+  # = Report
+  #
+  # The Report class is responsible two things:
+  #
+  # It adds information to the yaml report, produced by the system
+  # as a whole, for each of the generators used in this test run.
+  #
+  # It also handles passing the information from each generator used
+  # in this test run out to the template class set in
+  # MetricFu::Configuration.
+  class Report
+
+    # Renders the result of the report_hash into a yaml serialization
+    # ready for writing out to a file.
+    #
+    # @return YAML
+    #   A YAML object containing the results of the report generation
+    #   process
+    def to_yaml
+      report_hash.to_yaml
+    end
+
+    def per_file_data
+      @per_file_data ||= {}
+    end
+
+    def report_hash #:nodoc:
+      @report_hash ||= {}
+    end
+
+    # Instantiates a new template class based on the configuration set
+    # in MetricFu::Configuration, or through the MetricFu.config block
+    # in your rake file (defaults to the included AwesomeTemplate),
+    # assigns the report_hash to the report_hash in the template, and
+    # tells the template to to write itself out.
+    def save_templatized_report
+      @template = MetricFu.template_class.new
+      @template.report = report_hash
+      @template.per_file_data = per_file_data
+      @template.write
+    end
+
+    # Adds a hash from a passed report, produced by one of the Generator
+    # classes to the aggregate report_hash managed by this hash.
+    #
+    # @param report_type Hash
+    #   The hash to add to the aggregate report_hash
+    def add(report_type)
+      clazz = MetricFu.const_get(report_type.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase })
+      inst = clazz.new
+
+      report_hash.merge!(inst.generate_report)
+
+      inst.per_file_info(per_file_data) if inst.respond_to?(:per_file_info)
+    end
+
+    # Saves the passed in content to the passed in directory.  If
+    # a filename is passed in it will be used as the name of the
+    # file, otherwise it will default to 'index.html'
+    #
+    # @param content String
+    #   A string containing the content (usually html) to be written
+    #   to the file.
+    #
+    # @param dir String
+    #   A dir containing the path to the directory to write the file in.
+    #
+    # @param file String
+    #   A filename to save the path as.  Defaults to 'index.html'.
+    #
+    def save_output(content, dir, file='index.html')
+      open("#{dir}/#{file}", "w") do |f|
+        f.puts content
+      end
+    end
+
+    # Checks to discover whether we should try and open the results
+    # of the report in the browser on this system.  We only try and open
+    # in the browser if we're on OS X and we're not running in a
+    # CruiseControl.rb environment.  See MetricFu.configuration for more
+    # details about how we make those guesses.
+    #
+    # @return Boolean
+    #   Should we open in the browser or not?
+    def open_in_browser?
+      MetricFu.configuration.platform.include?('darwin') &&
+      ! MetricFu.configuration.is_cruise_control_rb?
+    end
+
+    # Shows 'index.html' from the passed directory in the browser
+    # if we're able to open the browser on this platform.
+    #
+    # @param dir String
+    #   The directory path where the 'index.html' we want to open is
+    #   stored
+    def show_in_browser(dir)
+      system("open #{dir}/index.html") if open_in_browser?
+    end
+  end
+end

data/lib/base/roodi_analyzer.rb

@@ -0,0 +1,37 @@
+class RoodiAnalyzer
+  include ScoringStrategies
+
+  COLUMNS = %w{problems}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :roodi
+  end
+
+  def map(row)
+    ScoringStrategies.present(row)
+  end
+
+  def reduce(scores)
+    ScoringStrategies.sum(scores)
+  end
+
+  def score(metric_ranking, item)
+    ScoringStrategies.percentile(metric_ranking, item)
+  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
+
+end

data/lib/base/saikuro_analyzer.rb

@@ -0,0 +1,48 @@
+class SaikuroAnalyzer
+  include ScoringStrategies
+
+  COLUMNS = %w{lines complexity}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :saikuro
+  end
+
+  def map(row)
+    row.complexity
+  end
+
+  def reduce(scores)
+    ScoringStrategies.average(scores)
+  end
+
+  def score(metric_ranking, item)
+    ScoringStrategies.identity(metric_ranking, item)
+  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
+
+end

data/lib/base/scoring_strategies.rb

@@ -0,0 +1,29 @@
+module ScoringStrategies
+
+  def percentile(ranking, item)
+    ranking.percentile(item) # per project score percentile
+  end
+
+  def identity(ranking, item)
+    ranking[item] # Use the score you got (ex flog score of 20 is not bad even if it is the top one in project)
+  end
+
+  def present(row)
+    1 # If present it's a one, not present it's a zero - For things like Reek that don't have a number
+  end
+
+  def sum(scores)
+    scores.inject(0) {|s,x| s+x}
+  end
+
+  def average(scores)
+    # remove dependency on statarray
+    # scores.to_statarray.mean
+    score_length = scores.length
+    sum = 0
+    sum = scores.inject( nil ) { |sum,x| sum ? sum+x : x }
+    (sum.to_f / score_length.to_f)
+  end
+
+  extend self
+end

data/lib/base/stats_analyzer.rb

@@ -0,0 +1,37 @@
+class StatsAnalyzer
+
+  COLUMNS = %w{stat_name stat_value}
+
+  def columns
+    COLUMNS
+  end
+
+  def name
+    :stats
+  end
+
+  def map(row)
+    0
+  end
+
+  def reduce(scores)
+    0
+  end
+
+  def score(metric_ranking, item)
+    0
+  end
+
+  def generate_records(data, table)
+    return if data == nil
+    data.each do |key, value|
+      next if value.kind_of?(Array)
+      table << {
+        "metric" => name,
+        "stat_name" => key,
+        "stat_value" => value
+      }
+    end
+  end
+
+end

data/lib/base/table.rb

@@ -0,0 +1,102 @@
+class Table
+
+  def initialize(opts = {})
+    @rows = []
+    @columns = opts.fetch(:column_names)
+
+    @make_index = opts.fetch(:make_index) {true}
+    @metric_index = {}
+  end
+
+  def <<(row)
+    record = nil
+    if row.is_a?(Record) || row.is_a?(CodeIssue)
+      record = row
+    else
+      record = Record.new(row, @columns)
+    end
+    @rows << record
+    updated_key_index(record) if @make_index
+  end
+
+  def each
+    @rows.each do |row|
+      yield row
+    end
+  end
+
+  def size
+    length
+  end
+
+  def length
+    @rows.length
+  end
+
+  def [](index)
+    @rows[index]
+  end
+
+  def column(column_name)
+    arr = []
+    @rows.each do |row|
+      arr << row[column_name]
+    end
+    arr
+  end
+
+  def group_by_metric
+    @metric_index.to_a
+  end
+
+  def rows_with(conditions)
+    if optimized_conditions?(conditions)
+      optimized_select(conditions)
+    else
+      slow_select(conditions)
+    end
+  end
+
+  def delete_at(index)
+    @rows.delete_at(index)
+  end
+
+  def to_a
+    @rows
+  end
+
+  def map
+    new_table = Table.new(:column_names => @columns)
+    @rows.map do |row|
+      new_table << (yield row)
+    end
+    new_table
+  end
+
+  private
+
+  def optimized_conditions?(conditions)
+    conditions.keys.length == 1 && conditions.keys.first.to_sym == :metric
+  end
+
+  def optimized_select(conditions)
+    metric = (conditions['metric'] || conditions[:metric]).to_s
+    @metric_index[metric].to_a.clone
+  end
+
+  def slow_select(conditions)
+    @rows.select do |row|
+      conditions.all? do |key, value|
+        row.has_key?(key.to_s) && row[key.to_s] == value
+      end
+    end
+  end
+
+  def updated_key_index(record)
+    if record.has_key?('metric')
+      @metric_index[record.metric] ||= Table.new(:column_names => @columns, :make_index => false)
+      @metric_index[record.metric] << record
+    end
+  end
+
+end

data/lib/generators/churn.rb

@@ -0,0 +1,28 @@
+module MetricFu
+
+  class Churn < Generator
+
+    def initialize(options={})
+      super
+    end
+
+    def emit
+      @output = `churn --yaml`
+      yaml_start = @output.index("---")
+      @output = @output[yaml_start...@output.length] if yaml_start
+    end
+
+    def analyze
+      if @output.match(/Churning requires a subversion or git repo/)
+        @churn = [:churn => {}]
+      else
+        @churn = YAML::load(@output)
+      end
+    end
+
+    def to_h
+      {:churn => @churn[:churn]}
+    end
+  end
+
+end

data/lib/generators/flay.rb

@@ -0,0 +1,31 @@
+require 'flay'
+
+module MetricFu
+
+  class Flay < Generator
+
+    def emit
+      mimimum_score_parameter = MetricFu.flay[:minimum_score] ? "--mass #{MetricFu.flay[:minimum_score]} " : ""
+
+      @output = `flay #{mimimum_score_parameter} #{MetricFu.flay[:dirs_to_flay].join(" ")}`
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n\n").map{|m| m.split("\n  ") }
+    end
+
+    def to_h
+      target = []
+      total_score = @matches.shift.first.split('=').last.strip
+      @matches.each do |problem|
+        reason = problem.shift.strip
+        lines_info = problem.map do |full_line|
+          name, line = full_line.split(":")
+          {:name => name.strip, :line => line.strip}
+        end
+        target << [:reason => reason, :matches => lines_info]
+      end
+      {:flay => {:total_score => total_score, :matches => target.flatten}}
+    end
+  end
+end

data/lib/generators/flog.rb

@@ -0,0 +1,111 @@
+require 'pathname'
+require 'optparse'
+require 'flog'
+
+module MetricFu
+
+  class Flog < Generator
+
+    def emit
+      files = []
+      MetricFu.flog[:dirs_to_flog].each do |directory|
+        directory = "." if directory=='./'
+        dir_files = Dir.glob("#{directory}/**/*.rb")
+        dir_files = remove_excluded_files(dir_files)
+        files += dir_files
+      end
+      options = ::Flog.parse_options ["--all", "--details"]
+
+      @flogger = ::Flog.new options
+      @flogger.flog files
+
+    rescue LoadError
+      if RUBY_PLATFORM =~ /java/
+        puts 'running in jruby - flog tasks not available'
+      end
+    end
+
+    def analyze
+      @method_containers = {}
+      @flogger.calls.each do |full_method_name, operators|
+        container_name = full_method_name.split('#').first
+        path = @flogger.method_locations[full_method_name]
+        if @method_containers[container_name]
+          @method_containers[container_name].add_method(full_method_name, operators, @flogger.totals[full_method_name], path)
+          @method_containers[container_name].add_path(path)
+        else
+          mc = MethodContainer.new(container_name, path)
+          mc.add_method(full_method_name, operators, @flogger.totals[full_method_name], path)
+          @method_containers[container_name] = mc
+        end
+      end
+    end
+
+    def to_h
+      sorted_containers = @method_containers.values.sort_by {|c| c.highest_score}.reverse
+      {:flog => { :total => @flogger.total,
+                  :average => @flogger.average,
+                  :method_containers => sorted_containers.map {|method_container| method_container.to_h}}}
+    end
+
+    def per_file_info(out)
+      @method_containers.each_pair do |klass, container|
+        container.methods.each_pair do |method_name, data|
+          next if data[:path].nil?
+
+          file, line = data[:path].split(':')
+
+          out[file] ||= {}
+          out[file][line] ||= []
+          out[file][line] << {:type => :flog, :description => "Score of %.2f" % data[:score]}
+        end
+      end
+    end
+  end
+
+  class MethodContainer
+    attr_reader :methods
+
+    def initialize(name, path)
+      @name = name
+      add_path path
+      @methods = {}
+    end
+
+    def add_path path
+      return unless path
+      @path ||= path.split(':').first
+    end
+
+    def add_method(full_method_name, operators, score, path)
+      @methods[full_method_name] = {:operators => operators, :score => score, :path => path}
+    end
+
+    def to_h
+      { :name => @name,
+        :path => @path || '',
+        :total_score => total_score,
+        :highest_score => highest_score,
+        :average_score => average_score,
+        :methods => @methods}
+    end
+
+    def highest_score
+      method_scores.max
+    end
+
+    private
+
+    def method_scores
+      @method_scores ||= @methods.values.map {|v| v[:score] }
+    end
+
+    def total_score
+      @total_score ||= method_scores.inject(0) {|sum, score| sum += score}
+    end
+
+    def average_score
+      total_score / method_scores.size.to_f
+    end
+  end
+end

data/lib/generators/hotspots.rb

@@ -0,0 +1,52 @@
+module MetricFu
+
+  class Hotspots < Generator
+
+    def initialize(options={})
+      super
+    end
+
+    def self.verify_dependencies!
+      true
+    end
+
+    def emit
+      @analyzer = MetricAnalyzer.new(MetricFu.report.report_hash)
+    end
+
+    def analyze
+      num = nil
+      worst_items = {}
+      if @analyzer
+        worst_items[:files] =
+          @analyzer.worst_files(num).inject([]) do |array, worst_file|
+          array <<
+            {:location => @analyzer.location(:file, worst_file),
+            :details => @analyzer.problems_with(:file, worst_file)}
+          array
+        end
+        worst_items[:classes] = @analyzer.worst_classes(num).inject([]) do |array, class_name|
+          location = @analyzer.location(:class, class_name)
+          array <<
+            {:location => location,
+            :details => @analyzer.problems_with(:class, class_name)}
+          array
+        end
+        worst_items[:methods] = @analyzer.worst_methods(num).inject([]) do |array, method_name|
+          location = @analyzer.location(:method, method_name)
+          array <<
+            {:location => location,
+            :details => @analyzer.problems_with(:method, method_name)}
+          array
+        end
+      end
+
+      @hotspots = worst_items
+    end
+
+    def to_h
+      {:hotspots => @hotspots}
+    end
+  end
+
+end

data/lib/generators/rails_best_practices.rb

@@ -0,0 +1,53 @@
+module MetricFu
+  class RailsBestPractices < Generator
+
+    def emit
+      @output = `rails_best_practices --without-color .`
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n").map{|m| m.split(" - ") }
+      total = @matches.pop
+      cleanup_color_switches(total.first)
+
+      2.times { @matches.pop } # ignore wiki link
+      @matches.reject! {|array| array.empty? }
+      @matches.map! do |match|
+        file, line = match[0].split(':')
+        problem = match[1]
+
+        cleanup_color_switches(file)
+        cleanup_color_switches(problem)
+
+        file.gsub!(/^\.\//, '')
+
+        {:file => file, :line => line, :problem => problem}
+      end
+      @rails_best_practices_results = {:total => total, :problems => @matches}
+    end
+
+    def cleanup_color_switches(str)
+      return if str.nil?
+      str.gsub!(%r{^\e\[3[1|2]m}, '')
+      str.gsub!(%r{\e\[0m$}, '')
+    end
+
+    def to_h
+      {:rails_best_practices => @rails_best_practices_results}
+    end
+
+    def per_file_info(out)
+      @rails_best_practices_results[:problems].each do |problem|
+        next if problem[:file] == '' || problem[:problem].nil?
+
+        out[problem[:file]] ||= {}
+
+        lines = problem[:line].split(/\s*,\s*/)
+        lines.each do |line|
+          out[problem[:file]][line] ||= []
+          out[problem[:file]][line] << {:type => :rails_best_practices, :description => problem[:problem]}
+        end
+      end
+    end
+  end
+end