edouard-metric_fu 1.0.4.5 → 1.1.1

data/HISTORY

@@ -1,3 +1,20 @@
+=== MetricFu 1.1.1 / 2009-6-29
+
+* Fix for empty flog files
+
+=== MetricFu 1.1.0 / 2009-6-22
+
+* Flog, flay, reek, roodi, and rcov reports now graph progress over time.  Well done Nick Quaranto and Edouard Brière.
+* 'Awesome' template has been brought in so that reports look 90% less 'ghetto.'  Also done by Nick Quaranto 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 @@
-Same as jscruggs/metric_fu, but with awesome templates and graphs.
+See http://metric-fu.rubyforge.org/ for documentation, or the HISTORY file for a change log.

data/Rakefile

@@ -15,33 +15,4 @@ MetricFu::Configuration.run do |config|
   config.template_class = AwesomeTemplate
 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.data_directory, 
-                                "#{Time.now.strftime("%Y%m%d")}.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.data_directory,
-                                  "#{Time.now.strftime("%Y%m%d")}.yml")
-      MetricFu.report.save_templatized_report
-      if MetricFu.report.open_in_browser?
-        MetricFu.report.show_in_browser(MetricFu.output_directory)
-      end
-    end
-  end
-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

@@ -119,7 +119,7 @@ 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(@base_directory, '_data')
+      @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, 

data/lib/base/generator.rb

@@ -33,6 +33,7 @@ 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
@@ -126,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

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)
@@ -58,10 +64,17 @@ module MetricFu
       total_flog_score = @pages.inject(0) {|total, page| total += page.score}
       sorted_pages = @pages.sort_by {|page| page.score }.reverse 
       {:flog => { :total => total_flog_score,
-                  :average => round_to_tenths(total_flog_score/number_of_methods),
+                  :average => average_score(total_flog_score, number_of_methods),
                   :pages => sorted_pages.map {|page| page.to_h}}}
     end
     
+    private
+    
+    def average_score(total_flog_score, number_of_methods)
+      return 0 if total_flog_score == 0
+      round_to_tenths(total_flog_score/number_of_methods)
+    end
+    
     def flog_results
       Dir.glob("#{metric_directory}/**/*.txt")
     end

data/lib/generators/rcov.rb

@@ -5,6 +5,17 @@ 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,216 +1,208 @@
 module MetricFu
  
-class Saikuro < Generator
+  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
  
-  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
+      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}
-      }
-    }
-    meths = meths.sort_by {|meth| meth.complexity.to_i}
-    @meths = meths.reverse
  
-  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
+    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
-    {: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")
+    def saikuro_results
+      Dir.glob("#{metric_directory}/**/*.html")
+    end
   end
  
-  private
+  class Saikuro::SFile
  
+    attr_reader :elements
+
+    def initialize(path)
+      @path = path
+      @file_handle = File.open(@path, "r")
+      @elements = []
+      get_elements
+    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|
-      unless f.readline.match /--/
-        return false
-      else
-        return true
+    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
-  end
  
-  def filename
-    File.basename(@path, '_cyclo.html')
-  end
+    def filename
+      File.basename(@path, '_cyclo.html')
+    end
  
-  def to_h
-    merge_classes
-    {:classes => @elements}
-  end
+    def to_h
+      merge_classes
+      {:classes => @elements}
+    end
  
-  def get_elements
-    begin
-      while ( line = @file_handle.readline) do
-       element ||= nil
-        if line.match /START/
-         unless element.nil?
-           @elements << element
+    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
-          line = @file_handle.readline
-          element = Saikuro::ParsingElement.new(line)
-        elsif line.match /END/
-          @elements << element unless element.nil?
-          element = nil
-        else
-          element << line
         end
+      rescue EOFError
+        nil
       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
+    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_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
+        new_elements << new_element
+      end
+      @elements = new_elements if new_elements
     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 get_class_names
+      class_names = []
+      @elements.each do |element|
+        unless class_names.include?(element.name)
+          class_names << element.name
+        end
       end
+      class_names
     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
+  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 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
+    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

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

@@ -10,7 +10,7 @@
   <% count = 0 %>
   <% @churn[:changes].each do |change| %>
     <tr>
-      <td><%= change[:file_path] %></td>
+      <td><%= link_to_filename(change[:file_path]) %></td>
       <td><%= change[:times_changed] %></td>
     </tr>
     <% count += 1 %>

data/lib/templates/awesome/default.css

@@ -60,6 +60,15 @@ table td.score {
 .rcov_not_run {
   background-color: #d88;
 }
+.rcov_run a, .rcov_not_run a {
+  text-decoration: none;
+}
+.rcov_run a {
+  color: #333;
+}
+.rcov_not_run a {
+  color: #000;
+}
 .rcov_overflow {
   overflow: auto;
   font-size: 50%;

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

@@ -16,7 +16,7 @@
     <tr class='<%= cycle("light", "dark", count) %>'>
       <td>
         <% match[:matches].each do |file| %>
-          <%= file[:name] %>:<%= file[:line] %><br />
+          <%= link_to_filename(file[:name], file[:line]) %><br/>
         <% end %>
       </td>
       <td><%= match[:reason] %></td>