jscruggs-metric_fu 1.0.2 → 1.1.0

data/HISTORY

@@ -1,3 +1,16 @@
+=== MetricFu 1.1.0 / 2009-6-22
+
+* Flog, flay, reek, roodi, and rcov reports now graph progress over time.  Well done Nick Quarantos and Edouard Brière.
+* 'Awesome' template has been brought in so that reports look 90% less 'ghetto.'  Also done by Nick Quarantos and Edouard Brière.
+* Added links to TextMate (which keep getting removed.  Probably by me. Sorry.) -- David Chelimsky
+* Fixed a bug for scratch files which have a size of 0 -- Kevin Hall
+* Changed gem dependencies from install-time in gemspec to runtime when each of the generators is loaded.  This allows use of github gems (i.e. relevance-rcov instead of rcov) and also allows you to install only the gems for the metrics you plan on using.  -- Alex Rothenberg
+* Empty Flog file fix -- Adam Bair
+* Added a simple fix for cases where Saikuro results with nested information -- Randy Souza
+* Fixed rcov configuration so it ignores library files on Linux -- Diego Carrion
+* Changing churn so that it still works deeper than the git root directory -- Andrew Timberlake
+* Andrew Timberlake also made some nice changes to the base template which kinda of got overshadowed by the 'awesome' template.  Sorry about that Andrew.
+
 === MetricFu 1.0.2 / 2009-5-11
 
 * Fixing problems with Reek new line character (thanks to all who pointed this out)

data/README

@@ -1 +1 @@
-See http://metric-fu.rubyforge.org/ for documentation, or the HISTORY file for a change log.
+See http://metric-fu.rubyforge.org/ for documentation, or the HISTORY file for a change log.

data/Rakefile

@@ -12,35 +12,7 @@ Spec::Rake::SpecTask.new(:spec) do |t|
 end
 
 MetricFu::Configuration.run do |config|
-end
-
-namespace :metrics do
-  desc "Generate all reports"
-  task :all do
-    MetricFu.metrics.each {|metric| MetricFu.report.add(metric) }
-    MetricFu.report.save_output(MetricFu.report.to_yaml,
-                                MetricFu.base_directory, 
-                                'report.yml')
-    MetricFu.report.save_templatized_report
-    if MetricFu.report.open_in_browser?
-      MetricFu.report.show_in_browser(MetricFu.output_directory)
-    end
-  end
-
-  MetricFu.metrics.each do |metric|
-    desc "Generate report for #{metric}"
-    task metric do
-
-      MetricFu.report.add(metric)
-      MetricFu.report.save_output(MetricFu.report.to_yaml,
-                                  MetricFu.base_directory,
-                                  'report.yml')
-      MetricFu.report.save_templatized_report
-      if MetricFu.report.open_in_browser?
-        MetricFu.report.show_in_browser(MetricFu.output_directory)
-      end
-    end
-  end
+  config.template_class = AwesomeTemplate
 end
 
 task :default => [:"metrics:all"]

data/TODO

@@ -1,9 +1,7 @@
 == TODO list
 
 * Color code flog results with scale from: http://jakescruggs.blogspot.com/2008/08/whats-good-flog-score.html
-* Extract functionality from rake files and put under test
 * Integrate Flog, Saikuro, and Coverage into one report so you can see methods that have high complexity and low coverage (this is a big one)
-* Integrate MD5 hashing with remainder of reports
 * Move HTML out of code and into templates/
 * Replace #generate_report with #new on each metric class
 * Make each class descend from MetricFu::CodeMetric
@@ -12,3 +10,4 @@
 * Add flay specs that run flay
 * Convert readme to markdown and rename to README.mkdn so github will render it
 * Saikuro.rb falls over if tries to parse an empty file.  Fair enough.  We shouldn't feed it empty files
+* Make running metric_fu on metric_fu less embarrassing 

data/lib/base/base_template.rb

@@ -99,16 +99,28 @@ module MetricFu
     #
     # @return String
     #   An anchor link to a textmate reference or a file reference
-    def link_to_filename(name, line = nil)
-      filename = File.expand_path(name)
+    def link_to_filename(name, line = nil, link_content = nil)
+      "<a href='#{file_url(name, line)}'>#{link_content(name, line, link_content)}</a>"
+    end
+    
+    def link_content(name, line=nil, link_content=nil) # :nodoc:
+      if link_content
+        link_content
+      elsif line
+        "#{name}:#{line}"
+      else
+        name
+      end
+    end
+    
+    def file_url(name, line) # :nodoc:
+      filename = File.expand_path(name.gsub(/^\//, ''))
       if MetricFu.configuration.platform.include?('darwin')
-        "<a href='txmt://open/?url=file://" \
-        +"#{filename}&line=#{line}'>#{name}:#{line}</a>"
+        "txmt://open/?url=file://#{filename}" << (line ? "&line=#{line}" : "")
       else 
-       "<a href='file://#{filename}'>#{name}:#{line}</a>"
+       "file://#{filename}"
       end
     end
-  
 
     # Provides a brain dead way to cycle between two values during
     # an iteration of some sort.  Pass in the first_value, the second_value,

data/lib/base/configuration.rb

@@ -8,6 +8,7 @@ module MetricFu
   AVAILABLE_METRICS = [:churn, :flog, :flay, :reek, 
                        :roodi, :saikuro, :rcov]
 
+  AVAILABLE_GRAPHS = [:flog, :flay, :reek, :roodi, :rcov]
 
   # The @@configuration class variable holds a global type configuration
   # object for any parts of the system to use.
@@ -118,12 +119,14 @@ module MetricFu
       @base_directory = ENV['CC_BUILD_ARTIFACTS'] || 'tmp/metric_fu'
       @scratch_directory = File.join(@base_directory, 'scratch')
       @output_directory = File.join(@base_directory, 'output')
+      @data_directory = File.join('tmp/metric_fu', '_data')
       @metric_fu_root_directory = File.join(File.dirname(__FILE__), 
                                                         '..', '..')
       @template_directory =  File.join(@metric_fu_root_directory, 
                                        'lib', 'templates') 
-      @template_class = StandardTemplate
+      @template_class = AwesomeTemplate
       set_metrics
+      set_graphs
       set_code_dirs
       @flay     = { :dirs_to_flay => @code_dirs  } 
       @flog     = { :dirs_to_flog => @code_dirs  }
@@ -146,7 +149,20 @@ module MetricFu
                                    "--no-color",
                                    "--profile",
                                    "--rails",
-                                   "--exclude /gems/,/Library/,spec"]}
+                                   "--exclude /gems/,/Library/,/usr/,spec"]}
+                                   
+      @graph_theme = { :colors => %w(orange purple green white red blue pink yellow),
+                       :marker_color => 'blue',
+                       :background_colors => %w(white white)}
+      
+      relative_font_path = [File.dirname(__FILE__), '..', '..', 'vendor', '_fonts', 'monaco.ttf']
+      @graph_font = File.expand_path(File.join(relative_font_path))
+      @graph_size = "1000x400"
+      @graph_title_font_size = 12
+      @graph_legend_box_size = 12
+      @graph_legend_font_size = 10
+      @graph_marker_font_size = 10
+      
     end
 
     # Perform a simple check to try and guess if we're running
@@ -166,6 +182,10 @@ module MetricFu
         @metrics = MetricFu::AVAILABLE_METRICS
       end 
     end
+    
+    def set_graphs
+      @graphs = MetricFu::AVAILABLE_GRAPHS 
+    end
 
     # Add the 'app' directory if we're running within rails.
     def set_code_dirs

data/lib/base/generator.rb

@@ -33,8 +33,10 @@ module MetricFu
     attr_reader :report, :template
 
     def initialize(options={})
+      self.class.verify_dependencies!
       create_metric_dir_if_missing
       create_output_dir_if_missing
+      create_data_dir_if_missing
     end
     
     # Creates a new generator and returns the output of the 
@@ -82,6 +84,12 @@ module MetricFu
         FileUtils.mkdir_p(MetricFu.output_directory, :verbose => false) 
       end
     end
+    
+    def create_data_dir_if_missing #:nodoc:
+      unless File.directory?(MetricFu.data_directory)
+        FileUtils.mkdir_p(MetricFu.data_directory, :verbose => false) 
+      end
+    end
 
     # @return String
     #   The path of the metric directory this class is using.
@@ -119,6 +127,11 @@ module MetricFu
     def round_to_tenths(decimal)
       (decimal * 10).round / 10.0 
     end
+    
+    # Allows subclasses to check for required gems
+    def self.verify_dependencies!
+      true
+    end
 
     def emit #:nodoc:
       raise <<-EOF
@@ -135,8 +148,8 @@ module MetricFu
         information.
       EOF
     end
-
-    def to_h #:nodoc:
+    
+    def to_graph #:nodoc:
       raise <<-EOF
         This method must be implemented by a concrete class descending
         from Generator.  See generator class documentation for more 

data/lib/base/graph.rb

@@ -0,0 +1,37 @@
+module MetricFu
+
+  def self.graph
+    @graph ||= Graph.new
+  end
+
+  class Graph
+    
+    attr_accessor :clazz
+    
+    def initialize
+      self.clazz = []
+    end
+    
+    def add(graph_type)
+      grapher_name = graph_type.to_s.capitalize + "Grapher"
+      self.clazz.push MetricFu.const_get(grapher_name).new
+    end
+    
+    
+    def generate
+      puts "Generating graphs"
+      Dir[File.join(MetricFu.data_directory, '*.yml')].sort.each do |metric_file|
+        puts "Generating graphs for #{metric_file}"
+        date = metric_file.split('/')[3].split('.')[0]
+        metrics = YAML::load(File.open(metric_file))
+        
+        self.clazz.each do |grapher|
+          grapher.get_metrics(metrics, date)
+        end
+      end
+      self.clazz.each do |grapher|
+        grapher.graph!
+      end
+    end
+  end
+end

data/lib/generators/churn.rb

@@ -4,9 +4,10 @@ module MetricFu
   
   class Churn < Generator
 
+    
     def initialize(options={})
       super
-      if File.exist?(".git")
+      if self.class.git?
         @source_control = Git.new(MetricFu.churn[:start_date])
       elsif File.exist?(".svn")
         @source_control = Svn.new(MetricFu.churn[:start_date])
@@ -16,6 +17,10 @@ module MetricFu
       @minimum_churn_count = MetricFu.churn[:minimum_churn_count] || 5
     end
 
+    def self.git?
+      system("git branch")
+    end
+    
     def emit
       @changes = parse_log_for_changes.reject {|file, change_count| change_count < @minimum_churn_count}
     end

data/lib/generators/flay.rb

@@ -3,6 +3,11 @@ module MetricFu
   
   class Flay < Generator
 
+    def self.verify_dependencies!
+      `flay --help`
+      raise 'sudo gem install flay # if you want the flay tasks' unless $?.success?
+    end
+
     def emit
       files_to_flay = MetricFu.flay[:dirs_to_flay].map{|dir| Dir[File.join(dir, "**/*.rb")] }
       @output = `flay #{files_to_flay.join(" ")}`

data/lib/generators/flog.rb

@@ -3,6 +3,11 @@ module MetricFu
   class Flog < Generator
     attr_reader :pages
 
+    def self.verify_dependencies!
+      `flog --help`
+      raise 'sudo gem install flog # if you want the flog tasks' unless $?.success?
+    end
+
     SCORE_FORMAT = "%0.2f"
     METHOD_LINE_REGEX = /(\d+\.\d+):\s+([A-Za-z:]+#.*)/
     OPERATOR_LINE_REGEX = /\s*(\d+\.\d+):\s(.*)$/
@@ -28,6 +33,7 @@ module MetricFu
 
     def parse(text)
       summary, methods_summary = text.split "\n\n"
+      return unless summary
       score, average = summary.split("\n").map {|line| line[OPERATOR_LINE_REGEX, 1]}
       return nil unless score && methods_summary
       page = Flog::Page.new(score, average)

data/lib/generators/rcov.rb

@@ -5,6 +5,16 @@ module MetricFu
   class Rcov < Generator
     NEW_FILE_MARKER =  ("=" * 80) + "\n"
 
+    def self.verify_dependencies!
+      `flay --help`
+      unless $?.success?
+        if RUBY_PLATFORM =~ /java/
+          raise 'running in jruby - rcov tasks not available'
+        else
+          raise 'sudo gem install rcov # if you want the rcov tasks'
+        end
+      end
+    end
 
     class Line
       attr_accessor :content, :was_run

data/lib/generators/reek.rb

@@ -3,6 +3,11 @@ 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(" ")}`

data/lib/generators/roodi.rb

@@ -1,5 +1,12 @@
 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(" ")}`

data/lib/generators/saikuro.rb

@@ -1,211 +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))
-    
-    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
+ 
+  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
-    end
-  end
-  
-  def format_directories
-    dirs = MetricFu.saikuro[:input_directory].join(" | ")
-    dirs = "\"#{dirs}\""
-    MetricFu.saikuro[:input_directory] = 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 
+ 
+      sh %{ruby "#{saikuro}" #{options_string}} do |ok, response|
+        unless ok
+          puts "Saikuro failed with exit status: #{response.exitstatus}"
+          exit 1
         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
+
+    def format_directories
+      dirs = MetricFu.saikuro[:input_directory].join(" | ")
+      "\"#{dirs}\""
     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}
+ 
+    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 
+      meths = meths.sort_by {|meth| meth.complexity.to_i}
+      @meths = meths.reverse
     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
-
-  private
-
-
-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|
-      unless f.readline.match /--/
-        return false
-      else
-        return true
+ 
+    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
-
-  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
-        if line.match /START/
-          line = @file_handle.readline
-          element = Saikuro::ParsingElement.new(line)
-        elsif line.match /END/
-          @elements << element 
-          element = nil
+ 
+  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
-          element << line
+          return true
         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
+ 
+    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 unless element.nil?
+            element = nil
+          else
+            element << line
+          end
+        end
+      rescue EOFError
+        nil
       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
+ 
+ 
+    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
-    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) 
+ 
+    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
-
-  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
+ 
+  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
-      base[:defs] = defs
+      return base
     end
-    return base
   end
 end
-
-
-end