devver-metric_fu 1.3.3

data/lib/generators/rails_best_practices.rb

@@ -0,0 +1,31 @@
+module MetricFu
+  class RailsBestPractices < Generator
+
+    def self.verify_dependencies!
+      `rails_best_practices --help`
+      raise 'sudo gem install rails_best_practices # if you want the rails_best_practices tasks' unless $?.success?
+    end
+
+    
+    def emit
+      @output = `rails_best_practices .`
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n").map{|m| m.split(" - ") }
+      total = @matches.pop
+      2.times { @matches.pop } # ignore wiki link
+      @matches.reject! {|array| array.empty? }
+      @matches.map! do |match|
+        file, line = match[0].split(':')
+        problem = match[1]
+        {:file => file, :line => line, :problem => problem}
+      end
+      @rails_best_practices_results = {:total => total, :problems => @matches}
+    end
+
+    def to_h
+      {:rails_best_practices => @rails_best_practices_results}
+    end
+  end
+end

data/lib/generators/rcov.rb

@@ -0,0 +1,82 @@
+require 'enumerator'
+
+module MetricFu
+
+  class Rcov < Generator
+    NEW_FILE_MARKER =  ("=" * 80) + "\n"
+
+    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
+      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
+
+
+    def analyze
+      output = File.open(MetricFu::Rcov.metric_directory + '/rcov.txt').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)
+      {:rcov => @rcov.merge({:global_percent_run => round_to_tenths(global_percent_run) })}   
+    end
+    
+    private
+    
+    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|
+          if raw_line.match(/^!!/)
+            line = Line.new(raw_line.gsub('!!', '  '), false).to_h
+          else
+            line = Line.new(raw_line, true).to_h
+          end
+        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,64 @@
+module MetricFu
+  
+  class Reek < Generator
+    REEK_REGEX = /^(\S+) (.*) \((.*)\)$/
+
+    def self.verify_dependencies!
+      `reek --help`
+      raise 'sudo gem install reek # if you want the reek tasks' unless $?.success?
+    end
+
+    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)
+      @output = `reek #{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
+
+  end
+end

data/lib/generators/roodi.rb

@@ -0,0 +1,33 @@
+module MetricFu
+  class Roodi < Generator
+
+    def self.verify_dependencies!
+      `roodi --help`
+      raise 'sudo gem install roodi # if you want the roodi tasks' unless $?.success?
+    end
+
+    
+    def emit
+      files_to_analyze = MetricFu.roodi[:dirs_to_roodi].map{|dir| Dir[File.join(dir, "**/*.rb")] }
+      files = remove_excluded_files(files_to_analyze.flatten)
+      config = MetricFu.roodi[:roodi_config] ? "-config=#{MetricFu.roodi[:roodi_config]}" : ""
+      @output = `roodi #{config} #{files.join(" ")}`
+    end
+
+    def analyze
+      @matches = @output.chomp.split("\n").map{|m| m.split(" - ") }
+      total = @matches.pop
+      @matches.reject! {|array| array.empty? }
+      @matches.map! do |match|
+        file, line = match[0].split(':')
+        problem = match[1]
+        {:file => file, :line => line, :problem => problem}
+      end
+      @roodi_results = {:total => total, :problems => @matches}
+    end
+
+    def to_h
+      {:roodi => @roodi_results}
+    end
+  end
+end

data/lib/generators/saikuro.rb

@@ -0,0 +1,221 @@
+module MetricFu
+ 
+  class Saikuro < Generator
+
+    def emit
+      MetricFu.saikuro[:input_directory] = format_directories
+ 
+      options_string = MetricFu.saikuro.inject("") do |options, option|
+        options + "--#{option.join(' ')} "
+      end
+ 
+      sh %{saikuro #{options_string}} do |ok, response|
+        unless ok
+          puts "Saikuro failed with exit status: #{response.exitstatus}"
+          exit 1
+        end
+      end
+    end
+
+    def format_directories
+      dirs = MetricFu.saikuro[:input_directory].join(" | ")
+      "\"#{dirs}\""
+    end
+ 
+    def analyze
+      @files = sort_files(assemble_files)
+      @classes = sort_classes(assemble_classes(@files))
+      @meths = sort_methods(assemble_methods(@files))
+    end
+ 
+    def to_h
+      files = @files.map do |file|
+        my_file = file.to_h
+        my_file[:filename] = file.filename
+        my_file
+      end
+      {:saikuro => {:files => files,
+                    :classes => @classes.map {|c| c.to_h},
+                    :methods => @meths.map {|m| m.to_h}
+                   }
+      }
+    end
+    
+    private
+    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 {|f| f.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
+      files = []
+      Dir.glob("#{metric_directory}/**/*.html").each do |path|
+        if Saikuro::SFile.is_valid_text_file?(path)
+          file = Saikuro::SFile.new(path)
+          if file
+            files << file
+          end
+        end
+      end
+      files
+    end
+    
+  end
+ 
+  class Saikuro::SFile
+ 
+    attr_reader :elements
+
+    def initialize(path)
+      @path = path
+      @file_handle = File.open(@path, "r")
+      @elements = []
+      get_elements
+    end
+ 
+    def self.is_valid_text_file?(path)
+      File.open(path, "r") do |f|
+        if f.eof? || !f.readline.match(/--/)
+          return false
+        else
+          return true
+        end
+      end
+    end
+ 
+    def filename
+      File.basename(@path, '_cyclo.html')
+    end
+ 
+    def to_h
+      merge_classes
+      {:classes => @elements}
+    end
+ 
+    def get_elements
+      begin
+        while (line = @file_handle.readline) do
+          return [] if line.nil? || line !~ /\S/
+          element ||= nil
+          if line.match /START/
+            unless element.nil?
+              @elements << element
+              element = nil
+            end
+            line = @file_handle.readline
+            element = Saikuro::ParsingElement.new(line)
+          elsif line.match /END/
+            @elements << element if element
+            element = nil
+          else
+            element << line if element
+          end
+        end
+      rescue EOFError
+        nil
+      end
+    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 {|d| d.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
+ 
+  class Saikuro::ParsingElement
+    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 << Saikuro::ParsingElement.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
+      return base
+    end
+  end
+end

data/lib/generators/stats.rb

@@ -0,0 +1,59 @@
+module MetricFu
+
+  class Stats < Generator
+
+    def emit
+      `rake stats > #{metric_directory + '/stats.txt'}`
+    end
+
+    def analyze
+      output = File.open(metric_directory + '/stats.txt').read
+      lines = remove_noise(output)
+
+      @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[0].chr != "+" }
+      lines = lines.find_all {|line| line[0].chr != "(" }
+      lines.shift
+      lines
+    end
+    
+    def set_global_stats(totals)
+      totals = totals.split("  ").find_all {|el| ! el.empty? }
+      @stats[:codeLOC] = totals[0].match(/\d.*/)[0].to_i
+      @stats[:testLOC] = totals[1].match(/\d.*/)[0].to_i
+      @stats[:code_to_test_ratio] = totals[2].match(/1\:(\d.*)/)[1].to_f
+    end
+    
+    def set_granular_stats(lines)
+      @stats[:lines] = lines.map do |line|
+        elements = line.split("|")
+        elements.map! {|el| el.strip }
+        elements = elements.find_all {|el| ! el.empty? }
+        info_line = {}
+        info_line[:name] = elements.shift
+        elements.map! {|el| el.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
+
+  end
+end