bf4-metric_fu 2.1.3.1

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,113 @@
+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"]
+      # TODO determine if flogging should continue despite errors
+      # options = ::Flog.parse_options ["--all", "--details", "--continue"]
+
+      @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,124 @@
+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"
+        mf_debug "** Running the specs/tests in the [#{MetricFu.rcov[:environment]}] environment"
+        command = %Q(RAILS_ENV=#{MetricFu.rcov[:environment]} rcov #{test_files} #{rcov_opts} #{output})
+        mf_debug "** #{command}"
+        `#{command}`
+      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/
+          STDOUT.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

data/lib/generators/reek.rb

@@ -0,0 +1,81 @@
+module MetricFu
+
+  class Reek < Generator
+    REEK_REGEX = /^(\S+) (.*) \((.*)\)$/
+
+    def emit
+      files_to_reek = MetricFu.reek[:dirs_to_reek].map{|dir| Dir[File.join(dir, "**/*.rb")] }
+      files = remove_excluded_files(files_to_reek.flatten)
+      config_file_param = MetricFu.reek[:config_file_pattern] ? "--config #{MetricFu.reek[:config_file_pattern]}" : ''
+      @output = `reek #{config_file_param} #{files.join(" ")}`
+      @output = massage_for_reek_12 if reek_12?
+    end
+
+    def reek_12?
+      return false if @output.length == 0
+      (@output =~ /^"/) != 0
+    end
+
+    def massage_for_reek_12
+      section_break = ''
+      @output.split("\n").map do |line|
+        case line
+        when /^  /
+          "#{line.gsub(/^  /, '')}\n"
+        else
+          parts = line.split(" -- ")
+          if parts[1].nil?
+            "#{line}\n"
+          else
+            warnings = parts[1].gsub(/ \(.*\):/, ':')
+            result = "#{section_break}\"#{parts[0]}\" -- #{warnings}\n"
+            section_break = "\n"
+            result
+          end
+        end
+      end.join
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n\n").map{|m| m.split("\n") }
+      @matches = @matches.map do |match|
+        file_path = match.shift.split('--').first
+        file_path = file_path.gsub('"', ' ').strip
+        code_smells = match.map do |smell|
+          match_object = smell.match(REEK_REGEX)
+          next unless match_object
+          {:method => match_object[1].strip,
+           :message => match_object[2].strip,
+           :type => match_object[3].strip}
+        end.compact
+        {:file_path => file_path, :code_smells => code_smells}
+      end
+    end
+
+    def to_h
+      {:reek => {:matches => @matches}}
+    end
+
+    def per_file_info(out)
+      @matches.each do |file_data|
+        next if File.extname(file_data[:file_path]) == '.erb'
+        begin
+          line_numbers = MetricFu::LineNumbers.new(File.open(file_data[:file_path], 'r').read)
+        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 reek information for this file."
+          next
+        end
+
+        out[file_data[:file_path]] ||= {}
+        file_data[:code_smells].each do |smell_data|
+          line = line_numbers.start_line_for_method(smell_data[:method])
+          out[file_data[:file_path]][line.to_s] ||= []
+          out[file_data[:file_path]][line.to_s] << {:type => :reek,
+                                                    :description => "#{smell_data[:type]} - #{smell_data[:message]}"}
+        end
+      end
+    end
+
+  end
+end