danmayer-metric_fu 2.1.2

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

data/lib/generators/rcov.rb

@@ -0,0 +1,122 @@
+require 'enumerator'
+
+module MetricFu
+
+  class Rcov < Generator
+    NEW_FILE_MARKER = /^={80}$/.freeze
+
+    class Line
+      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
+    end
+
+    def emit
+      unless MetricFu.rcov[:external]
+        FileUtils.rm_rf(MetricFu::Rcov.metric_directory, :verbose => false)
+        Dir.mkdir(MetricFu::Rcov.metric_directory)
+        test_files = FileList[*MetricFu.rcov[:test_files]].join(' ')
+        rcov_opts = MetricFu.rcov[:rcov_opts].join(' ')
+        output = ">> #{MetricFu::Rcov.metric_directory}/rcov.txt"
+        puts "** Running the specs/tests in the [#{MetricFu.rcov[:environment]}] environment"
+        `RAILS_ENV=#{MetricFu.rcov[:environment]} rcov #{test_files} #{rcov_opts} #{output}`
+      end
+    end
+
+
+    def analyze
+      output_file = MetricFu.rcov[:external] ? MetricFu.rcov[:external] : MetricFu::Rcov.metric_directory + '/rcov.txt'
+      output = File.open(output_file).read
+      output = output.split(NEW_FILE_MARKER)
+
+      output.shift # Throw away the first entry - it's the execution time etc.
+
+      files = assemble_files(output)
+
+      @global_total_lines = 0
+      @global_total_lines_run = 0
+
+      @rcov = add_coverage_percentage(files)
+    end
+
+    def to_h
+      global_percent_run = ((@global_total_lines_run.to_f / @global_total_lines.to_f) * 100)
+      add_method_data
+      {:rcov => @rcov.merge({:global_percent_run => round_to_tenths(global_percent_run) })}
+    end
+
+    private
+
+    def add_method_data
+      @rcov.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/
+          puts "ruby_parser blew up while trying to parse #{file_path}. You won't have method level Rcov 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
+
+        @rcov[file_path][:methods] = {}
+
+        method_coverage_map.each do |method_name, coverage_data|
+          @rcov[file_path][:methods][method_name] = (coverage_data[:uncovered] / coverage_data[:total].to_f) * 100.0
+        end
+
+      end
+    end
+
+    def assemble_files(output)
+      files = {}
+      output.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|
+          line = Line.new(raw_line[3..-1], !raw_line.match(/^!!/)).to_h
+        end
+        content.reject! {|line| line[:content].blank? }
+        files[fname] = {:lines => content}
+      end
+      files
+    end
+
+    def add_coverage_percentage(files)
+      files.each_pair do |fname, content|
+        lines = content[:lines]
+        @global_total_lines_run += lines_run = lines.find_all {|line| line[:was_run] == true }.length
+        @global_total_lines += total_lines = lines.length
+        percent_run = ((lines_run.to_f / total_lines.to_f) * 100).round
+        files[fname][:percent_run] = percent_run
+      end
+    end
+
+  end
+end