iain-metric_fu 0.1.0

data/lib/generators/reek.rb

@@ -0,0 +1,37 @@
+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")] }
+      @output = `reek #{files_to_reek.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,31 @@
+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")] }
+      @output = `roodi #{files_to_analyze.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,208 @@
+module MetricFu
+ 
+  class Saikuro < Generator
+
+    def emit
+      relative_path = [File.dirname(__FILE__), '..', '..',
+                       'vendor', 'saikuro', 'saikuro.rb']
+      saikuro = File.expand_path(File.join(relative_path))
+ 
+      MetricFu.saikuro[:input_directory] = format_directories
+ 
+      options_string = MetricFu.saikuro.inject("") do |options, option|
+        options + "--#{option.join(' ')} "
+      end
+ 
+      sh %{ruby "#{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 = []
+      saikuro_results.each do |path|
+        if Saikuro::SFile.is_valid_text_file?(path)
+          file = Saikuro::SFile.new(path)
+          if file
+            @files << file
+          end
+        end
+      end
+      @files = @files.sort_by do |file|
+        file.elements.
+             max {|a,b| a.complexity.to_i <=> b.complexity.to_i}.
+             complexity.to_i
+      end
+      @files.reverse!
+      klasses = []
+      @files.each {|f| klasses << f.elements}
+      klasses.flatten!
+      @classes = klasses.sort_by {|k| k.complexity.to_i}
+      @classes.reverse!
+      meths = []
+      @files.each {|f|
+        f.elements.each {|el|
+          el.defs.each {|defn|
+            defn.name = "#{el.name}##{defn.name}"
+            meths << defn}
+        }
+      }
+      meths = meths.sort_by {|meth| meth.complexity.to_i}
+      @meths = meths.reverse
+    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
+ 
+    def saikuro_results
+      Dir.glob("#{metric_directory}/**/*.html")
+    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,43 @@
+module MetricFu
+
+  class Stats < Generator
+
+    def emit
+      `rake stats > #{metric_directory + '/stats.txt'}`
+    end
+
+    def analyze
+      output = File.open(metric_directory + '/stats.txt').read
+      output = output.split("\n")
+      output = output.find_all {|line| line[0].chr != "+" }
+      output = output.find_all {|line| line[0].chr != "(" }
+      output.shift
+      totals = output.pop
+      totals = totals.split("  ").find_all {|el| ! el.empty? }
+      @stats = {}
+      @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
+      
+      @stats[:lines] = output.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
+      @stats
+    end
+
+    def to_h
+      {:stats => @stats}
+    end
+
+  end
+end

data/lib/graphs/flay_grapher.rb

@@ -0,0 +1,35 @@
+
+module MetricFu
+  
+  class FlayGrapher < Grapher
+    
+    attr_accessor :flay_score, :labels
+    
+    def initialize
+      super
+      self.flay_score = []
+      self.labels = {}
+    end
+    
+    def get_metrics(metrics, date)
+      self.flay_score.push(metrics[:flay][:total_score].to_i)
+      self.labels.update( { self.labels.size => date })
+    end
+    
+    def graph!
+      g = Gruff::Line.new(MetricFu.graph_size)
+      g.title = "Flay: duplication"
+      g.theme = MetricFu.graph_theme
+      g.font = MetricFu.graph_font
+      g.data('flay', self.flay_score)
+      g.labels = self.labels
+      g.title_font_size = MetricFu.graph_title_font_size
+      g.legend_box_size = MetricFu.graph_legend_box_size
+      g.legend_font_size = MetricFu.graph_legend_font_size
+      g.marker_font_size = MetricFu.graph_marker_font_size
+      g.write(File.join(MetricFu.output_directory, 'flay.png'))
+    end
+    
+  end
+  
+end

data/lib/graphs/flog_grapher.rb

@@ -0,0 +1,51 @@
+module MetricFu
+  
+  class FlogGrapher < Grapher
+    
+    attr_accessor :flog_average, :labels, :top_five_percent_average
+    
+    def initialize
+      super
+      self.flog_average = []
+      self.labels = {}
+      self.top_five_percent_average =[]
+    end
+    
+    def get_metrics(metrics, date)
+      self.top_five_percent_average.push(calc_top_five_percent_average(metrics))
+      self.flog_average.push(metrics[:flog][:average])
+      self.labels.update( { self.labels.size => date })
+    end
+    
+    def graph!
+      g = Gruff::Line.new(MetricFu.graph_size)
+      g.title = "Flog: code complexity"
+      g.theme = MetricFu.graph_theme
+      g.font = MetricFu.graph_font
+      g.data('top five percent average', self.top_five_percent_average)
+      g.data('flog average', self.flog_average)
+      g.labels = self.labels
+      g.title_font_size = MetricFu.graph_title_font_size
+      g.legend_box_size = MetricFu.graph_legend_box_size
+      g.legend_font_size = MetricFu.graph_legend_font_size
+      g.marker_font_size = MetricFu.graph_marker_font_size
+      g.write(File.join(MetricFu.output_directory, 'flog.png'))
+    end
+    
+    private
+    
+    def calc_top_five_percent_average(metrics)
+      methods = metrics[:flog][:pages].inject([]) {|methods, page| methods << page[:scanned_methods]}
+      methods.flatten!
+      
+      methods = methods.sort_by {|method| method[:score]}.reverse
+
+      number_of_methods_that_is_five_percent = (methods.size * 0.05).ceil
+
+      total_for_five_percent = methods[0...number_of_methods_that_is_five_percent].inject(0) {|total, method| total += method[:score]}
+      total_for_five_percent / number_of_methods_that_is_five_percent.to_f
+    end
+    
+  end
+  
+end

data/lib/graphs/grapher.rb

@@ -0,0 +1,19 @@
+module MetricFu
+  class Grapher
+    def initialize
+      self.class.require_gruff
+    end
+    
+    def self.require_gruff
+      require 'gruff'
+    rescue LoadError
+      puts "#"*99 + "\n" +
+           "If you want to use metric_fu's graphing features then you'll need to install the gems " + 
+           "'topfunky-gruff' (or 'umang-gruff' if you use 1.9x) and 'rmagick' (and rmagick requires ImageMagick).  "+
+           "If you don't want to deal with that, then make sure you set config.graphs = [] (see the metric_fu's homepage for more details) "+
+           "to indicate that you don't want graphing." +
+           "\n" + "#"*99 
+      raise
+    end
+  end
+end

data/lib/graphs/rcov_grapher.rb

@@ -0,0 +1,34 @@
+module MetricFu
+  
+  class RcovGrapher < Grapher
+    
+    attr_accessor :rcov_percent, :labels
+    
+    def initialize
+      super
+      self.rcov_percent = []
+      self.labels = {}
+    end
+    
+    def get_metrics(metrics, date)
+      self.rcov_percent.push(metrics[:rcov][:global_percent_run])
+      self.labels.update( { self.labels.size => date })
+    end
+    
+    def graph!
+      g = Gruff::Line.new(MetricFu.graph_size)
+      g.title = "Rcov: code coverage"
+      g.theme = MetricFu.graph_theme
+      g.font = MetricFu.graph_font
+      g.data('rcov', self.rcov_percent)
+      g.labels = self.labels
+      g.title_font_size = MetricFu.graph_title_font_size
+      g.legend_box_size = MetricFu.graph_legend_box_size
+      g.legend_font_size = MetricFu.graph_legend_font_size
+      g.marker_font_size = MetricFu.graph_marker_font_size
+      g.write(File.join(MetricFu.output_directory, 'rcov.png'))
+    end
+    
+  end
+  
+end

data/lib/graphs/reek_grapher.rb

@@ -0,0 +1,44 @@
+module MetricFu
+  
+  class ReekGrapher < Grapher
+    
+    attr_accessor :reek_count, :labels
+    
+    def initialize
+      super
+      self.reek_count = {}
+      self.labels= {}
+    end
+    
+    def get_metrics(metrics, date)
+      counter = self.labels.size
+      self.labels.update( { counter => date })
+      
+      metrics[:reek][:matches].each do |reek_chunk|
+        reek_chunk[:code_smells].each do |code_smell|
+          # speaking of code smell...
+          self.reek_count[code_smell[:type]] = [] if self.reek_count[code_smell[:type]].nil?
+          self.reek_count[code_smell[:type]][counter].nil? ? self.reek_count[code_smell[:type]][counter] = 1 : self.reek_count[code_smell[:type]][counter] += 1
+        end
+      end
+    end
+    
+    def graph!
+      g = Gruff::Line.new(MetricFu.graph_size)
+      g.title = "Reek: code smells"
+      g.theme = MetricFu.graph_theme
+      g.font = MetricFu.graph_font
+      self.reek_count.each_pair do |type, count|
+        g.data(type, count)
+      end
+      g.labels = self.labels
+      g.title_font_size = MetricFu.graph_title_font_size
+      g.legend_box_size = MetricFu.graph_legend_box_size
+      g.legend_font_size = MetricFu.graph_legend_font_size
+      g.marker_font_size = MetricFu.graph_marker_font_size
+      g.write(File.join(MetricFu.output_directory, 'reek.png'))
+    end
+    
+  end
+  
+end

data/lib/graphs/roodi_grapher.rb

@@ -0,0 +1,34 @@
+module MetricFu
+  
+  class RoodiGrapher < Grapher
+    
+    attr_accessor :roodi_count, :labels
+    
+    def initialize
+      super
+      self.roodi_count = []
+      self.labels = {}
+    end
+    
+    def get_metrics(metrics, date)
+      self.roodi_count.push(metrics[:roodi][:problems].size)
+      self.labels.update( { self.labels.size  => date })
+    end
+    
+    def graph!
+      g = Gruff::Line.new(MetricFu.graph_size)
+      g.title = "Roodi: design problems"
+      g.theme = MetricFu.graph_theme
+      g.font = MetricFu.graph_font
+      g.data('roodi', self.roodi_count)
+      g.labels = self.labels
+      g.title_font_size = MetricFu.graph_title_font_size
+      g.legend_box_size = MetricFu.graph_legend_box_size
+      g.legend_font_size = MetricFu.graph_legend_font_size
+      g.marker_font_size = MetricFu.graph_marker_font_size
+      g.write(File.join(MetricFu.output_directory, 'roodi.png'))
+    end
+    
+  end
+  
+end

data/lib/graphs/stats_grapher.rb

@@ -0,0 +1,37 @@
+module MetricFu
+
+  class StatsGrapher < Grapher
+
+    attr_accessor :lines_of_code, :labels, :lines_of_test
+
+    def initialize
+      super
+      self.lines_of_code = []
+      self.labels = {}
+      self.lines_of_test =[]
+    end
+
+    def get_metrics(metrics, date)
+      self.lines_of_test.push(metrics[:stats][:testLOC])
+      self.lines_of_code.push(metrics[:stats][:codeLOC])
+      self.labels.update( { self.labels.size => date })
+    end
+
+    def graph!
+      g = Gruff::Line.new(MetricFu.graph_size)
+      g.title = "Stats: Rails project size"
+      g.theme = MetricFu.graph_theme
+      g.font = MetricFu.graph_font
+      g.data('lines of code', self.lines_of_code)
+      g.data('lines of test', self.lines_of_test)
+      g.labels = self.labels
+      g.title_font_size = MetricFu.graph_title_font_size
+      g.legend_box_size = MetricFu.graph_legend_box_size
+      g.legend_font_size = MetricFu.graph_legend_font_size
+      g.marker_font_size = MetricFu.graph_marker_font_size
+      g.write(File.join(MetricFu.output_directory, 'stats.png'))
+    end
+
+  end
+
+end

data/lib/metric_fu.rb

@@ -0,0 +1,30 @@
+require 'rake'
+require 'yaml'
+# Load a few things to make our lives easier elsewhere.
+module MetricFu
+  LIB_ROOT = File.dirname(__FILE__)
+end
+base_dir = File.join(MetricFu::LIB_ROOT, 'base')
+generator_dir = File.join(MetricFu::LIB_ROOT, 'generators')
+template_dir  = File.join(MetricFu::LIB_ROOT, 'templates')
+graph_dir     = File.join(MetricFu::LIB_ROOT, 'graphs')
+
+# We need to require these two things first because our other classes
+# depend on them.
+require File.join(base_dir, 'report') 
+require File.join(base_dir, 'generator')
+require File.join(base_dir, 'graph')
+
+# prevent the task from being run multiple times.
+unless Rake::Task.task_defined? "metrics:all"
+  # Load the rakefile so users of the gem get the default metric_fu task
+  load File.join(MetricFu::LIB_ROOT, '..', 'tasks', 'metric_fu.rake')
+end
+
+# Now load everything else that's in the directory
+Dir[File.join(base_dir, '*.rb')].each{|l| require l }
+Dir[File.join(generator_dir, '*.rb')].each {|l| require l }
+Dir[File.join(template_dir, 'standard/*.rb')].each {|l| require l}
+Dir[File.join(template_dir, 'awesome/*.rb')].each {|l| require l}
+require graph_dir + "/grapher"
+Dir[File.join(graph_dir, '*.rb')].each {|l| require l}

data/lib/templates/awesome/awesome_template.rb

@@ -0,0 +1,30 @@
+class AwesomeTemplate < MetricFu::Template
+
+  def write
+    # Getting rid of the crap before and after the project name from integrity
+    @name = File.basename(Dir.pwd).gsub(/^\w+-|-\w+$/, "")
+
+    report.each_pair do |section, contents|
+      if template_exists?(section)
+        create_instance_var(section, contents)
+        @html = erbify(section)
+        html = erbify('layout')
+        fn = output_filename(section)
+        MetricFu.report.save_output(html, MetricFu.output_directory, fn)
+      end
+    end
+
+    # Instance variables we need should already be created from above
+    if template_exists?('index')
+      @html = erbify('index')
+      html = erbify('layout')
+      fn = output_filename('index')
+      MetricFu.report.save_output(html, MetricFu.output_directory, fn)
+    end
+  end
+
+  def this_directory
+    File.dirname(__FILE__)
+  end
+end
+

data/lib/templates/awesome/churn.html.erb

@@ -0,0 +1,19 @@
+<h3>Source Control Churn Results</h3>
+<p>Files that change a lot in your project may be bad a sign.
+  This task uses your source control log to identify those files.
+  </p>
+<table class="sortable">
+  <tr>
+    <th>File Path</th>
+    <th>Times Changed</th>
+  </tr>
+  <% count = 0 %>
+  <% @churn[:changes].each do |change| %>
+    <tr>
+      <td><%= link_to_filename(change[:file_path]) %></td>
+      <td><%= change[:times_changed] %></td>
+    </tr>
+    <% count += 1 %>
+  <% end %>
+</table>
+<p>Generated on <%= Time.now.localtime %></p>