metric_fu 1.4.0 → 1.5.0

data/HISTORY

@@ -1,3 +1,11 @@
+=== MetricFu 1.5.0 / 2010-4-27
+
+* Fixed bug where Flay results were not being reported.  Had to remove the ability to remove selected files from flay processing (undocumented feature that may go away soon if it keeps causing problems).  
+* Rewrote Flog parsing/processing to use Flog programmatically. Note: the yaml output for Flog has changed significantly - Pages have now become MethodContainers.  This probably doesn't matter to you if you are not consuming the metric_fu yaml output.  
+* Added support for using config files in Reek and Roodi (roodi support was already there but undocumented).
+* Removed verify_dependencies! as it caused too much confusion to justify the limited set of problems it solved. In the post Bundler world it just didn't seem necessary to limit metric_fu dependencies.
+* Deal with Rails 3 activesupport vs active_support problems. -  jinzhu
+
 === MetricFu 1.4.0 / 2010-06-19
 
 * Added support for rails_best_practices gem - Richard Huang

data/Rakefile

@@ -10,7 +10,7 @@ Spec::Rake::SpecTask.new(:spec) do |t|
 end
  
 MetricFu::Configuration.run do |config|
-  config.template_class = AwesomeTemplate
+  config.roodi = config.roodi.merge(:roodi_config => 'config/roodi_config.yml')
 end
  
 task :default => :spec

data/lib/base/base_template.rb

@@ -103,6 +103,10 @@ module MetricFu
       "<a href='#{file_url(name, line)}'>#{link_content(name, line, link_content)}</a>"
     end
     
+    def round_to_tenths(decimal)
+      (decimal * 10).round / 10.0 
+    end
+    
     def link_content(name, line=nil, link_content=nil) # :nodoc:
       if link_content
         link_content
@@ -114,6 +118,7 @@ module MetricFu
     end
     
     def file_url(name, line) # :nodoc:
+      return '' unless name
       filename = File.expand_path(name.gsub(/^\//, ''))
       if MetricFu.configuration.platform.include?('darwin')
         "txmt://open/?url=file://#{filename}" << (line ? "&line=#{line}" : "")

data/lib/base/configuration.rb

@@ -113,8 +113,10 @@ module MetricFu
                     :minimum_score => 100,
                     :filetypes => ['rb'] } 
       @flog     = { :dirs_to_flog => @code_dirs  }
-      @reek     = { :dirs_to_reek => @code_dirs  }
-      @roodi    = { :dirs_to_roodi => @code_dirs }
+      @reek     = { :dirs_to_reek => @code_dirs,
+                    :config_file_pattern => nil}
+      @roodi    = { :dirs_to_roodi => @code_dirs,
+                    :roodi_config => nil}
       @saikuro  = { :output_directory => @scratch_directory + '/saikuro', 
                     :input_directory => @code_dirs,
                     :cyclo => "",

data/lib/base/generator.rb

@@ -33,7 +33,6 @@ 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
@@ -134,11 +133,6 @@ 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

@@ -5,12 +5,6 @@ module MetricFu
     def initialize(options={})
       super
     end
-
-    def self.verify_dependencies!
-      result = `churn --help`
-      raise 'sudo gem install churn # if you want the churn tasks' unless result.match(/churn/)
-    end
-
     
     def emit
       @output = `churn --yaml`

data/lib/generators/flay.rb

@@ -1,21 +1,13 @@
+require 'flay'
+
 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| 
-        MetricFu.flay[:filetypes].map {|type|
-          Dir[  File.join(dir, "**/*.#{type}") ] 
-        }.flatten
-      }
-      files = remove_excluded_files(files_to_flay.flatten)
       mimimum_score_parameter = MetricFu.flay[:minimum_score] ? "--mass #{MetricFu.flay[:minimum_score]} " : ""
-      @output = `flay #{mimimum_score_parameter}#{files.join(" ")}`
+
+      @output = `flay #{mimimum_score_parameter} #{MetricFu.flay[:dirs_to_flay].join(" ")}`
     end
 
     def analyze

data/lib/generators/flog.rb

@@ -1,172 +1,98 @@
 require 'pathname'
+require 'optparse'
+require 'flog'
 
 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(.*)$/
 
     def emit
-      metric_dir = MetricFu::Flog.metric_directory
+      files = []
       MetricFu.flog[:dirs_to_flog].each do |directory|
         directory = "." if directory=='./'
-        files = Dir.glob("#{directory}/**/*.rb")
-        files = remove_excluded_files(files)
-        files.each do |filename|
-          output_dir = "#{metric_dir}/#{filename.split("/")[0..-2].join("/")}"
-          mkdir_p(output_dir, :verbose => false) unless File.directory?(output_dir)
-          pathname         = Pathname.new(filename)
-          if MetricFu::MD5Tracker.file_changed?(filename, metric_dir) 
-		base_name = pathname.basename.to_s.gsub(/\..*$/,'.txt')
-                editted_filename = File.join(pathname.dirname.to_s, base_name)
-         `flog -ad #{filename} > #{metric_dir}/#{editted_filename}`
-          end
-        end
+        dir_files = Dir.glob("#{directory}/**/*.rb")
+        dir_files = remove_excluded_files(dir_files)
+        files += dir_files
       end
+      options = ::Flog.parse_options ["--all", "--details"]
+
+      @flogger = ::Flog.new options
+      @flogger.flog files
+
     rescue LoadError
       if RUBY_PLATFORM =~ /java/
         puts 'running in jruby - flog tasks not available'
-      else
-        puts 'sudo gem install flog # if you want the flog tasks'
-      end
-    end
-
-    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)
-      methods_summary.each_line do |method_line|
-        if match = method_line.match(METHOD_LINE_REGEX)
-         page.scanned_methods << ScannedMethod.new(match[2], match[1])
-        elsif match = method_line.match(OPERATOR_LINE_REGEX)
-          return if page.scanned_methods.empty?
-          page.scanned_methods.last.operators << Operator.new(match[1], match[2])
-        end
       end
-      page
     end
 
     def analyze
-      @pages = []
-      flog_results.each do |path|
-        page = parse(open(path, "r") { |f| f.read })
-        if page
-          page.path = path.sub(metric_directory, "").sub(".txt", ".rb") 
-          #don't include old cached flog results for files that no longer exist.
-	  if is_file_current?(page.path.to_s)
-            @pages << page
-          end
+      @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
-      number_of_methods = @pages.inject(0) {|count, page| count += page.scanned_methods.size}
-      total_flog_score = @pages.inject(0) {|total, page| total += page.score}
-      sorted_pages = @pages.sort_by {|page| page.highest_score }.reverse 
-      {:flog => { :total => total_flog_score,
-                  :average => average_score(total_flog_score, number_of_methods),
-                  :pages => sorted_pages.map {|page| page.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
-    
-    private
 
-    def is_file_current?(pathname)
-      pathname        = pathname.gsub(/^\//,'')
-      local_pathname  = "./#{pathname}"
-      exists = false
+  end
 
-      MetricFu.flog[:dirs_to_flog].each do |directory|
-      	directory = "." if directory=='./'
-        files = Dir.glob("#{directory}/**/*.rb")
-        if files.include?(pathname) || files.include?(local_pathname)
-          exists = true
-          break
-        end
-      end
-      exists
-    end
+  class MethodContainer
+    attr_reader :methods
 
-    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)
+    def initialize(name, path)
+      @name = name
+      add_path path
+      @methods = {}
     end
-    
-    def flog_results
-      Dir.glob("#{metric_directory}/**/*.txt")
-    end
-  
-    class Operator
-      attr_accessor :score, :operator
-
-      def initialize(score, operator)
-        @score = score.to_f
-        @operator = operator
-      end
-    
-      def to_h
-        {:score => @score, :operator => @operator}
-      end
-    end  
-
-    class ScannedMethod
-      attr_accessor :name, :score, :operators, :line
 
-      def initialize(name, score, operators = [])
-        if name.match(/\.rb:\d*/)
-          @line = name.match(/\.rb:\d*/).to_s.sub('.rb:','')
-          name = name.match(/\S*/)
-        end
-        @name = name
-        @score = score.to_f
-        @operators = operators
-      end
+    def add_path path
+      return unless path
+      @path ||= path.split(':').first
+    end
 
-      def to_h
-        {:name => @name,
-          :score => @score,
-          :operators => @operators.map {|o| o.to_h},
-          :line => @line}
-      end
-    end  
-  
-  end
+    def add_method(full_method_name, operators, score, path)
+      @methods[full_method_name] = {:operators => operators, :score => score, :path => path}
+    end
 
-  class Flog::Page < MetricFu::Generator
-    attr_accessor :path, :score, :scanned_methods, :average_score
+    def to_h
+      { :name => @name,
+        :path => @path || '',
+        :total_score => total_score,
+        :highest_score => highest_score,
+        :average_score => average_score,
+        :methods => @methods}
+    end
 
-    def initialize(score, average_score, scanned_methods = [])
-      @score = score.to_f
-      @scanned_methods = scanned_methods
-      @average_score = average_score.to_f
+    def highest_score
+      method_scores.max
     end
 
-    def filename 
-      File.basename(path, ".txt") 
+    private
+
+    def method_scores
+      @method_scores ||= @methods.values.map {|v| v[:score] }
     end
 
-    def to_h
-      {:score => @score, 
-       :scanned_methods => @scanned_methods.map {|sm| sm.to_h},
-       :highest_score => highest_score,
-       :average_score => average_score,
-       :path => path}
+    def total_score
+      @total_score ||= method_scores.inject(0) {|sum, score| sum += score}
     end
 
-    def highest_score
-      scanned_methods.inject(0) do |highest, m|
-        m.score > highest ? m.score : highest
-      end
+    def average_score
+      total_score / method_scores.size.to_f
     end
-  end  
+  end
 end

data/lib/generators/rails_best_practices.rb

@@ -1,11 +1,5 @@
 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 .`

data/lib/generators/reek.rb

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

data/lib/generators/roodi.rb

@@ -1,12 +1,6 @@
 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)

data/lib/graphs/flog_grapher.rb

@@ -20,6 +20,25 @@ module MetricFu
     private
     
     def calc_top_five_percent_average(metrics)
+      return calc_top_five_percent_average_legacy(metrics) if metrics[:flog][:pages]
+      
+      method_scores = metrics[:flog][:method_containers].inject([]) do |method_scores, container| 
+        method_scores += container[:methods].values.map {|v| v[:score]}
+      end
+      method_scores.sort!.reverse!
+
+      number_of_methods_that_is_five_percent = (method_scores.size * 0.05).ceil
+
+      total_for_five_percent =
+        method_scores[0...number_of_methods_that_is_five_percent].inject(0) { |total, score| total += score }
+      if number_of_methods_that_is_five_percent == 0
+        0.0
+      else
+        total_for_five_percent / number_of_methods_that_is_five_percent.to_f
+      end
+    end
+    
+    def calc_top_five_percent_average_legacy(metrics)
       methods = metrics[:flog][:pages].inject([]) {|methods, page| methods << page[:scanned_methods]}
       methods.flatten!
       methods = methods.sort_by {|method| method[:score]}.reverse
@@ -34,7 +53,6 @@ module MetricFu
         total_for_five_percent / number_of_methods_that_is_five_percent.to_f
       end
     end
-    
   end
   
 end

data/lib/metric_fu.rb

@@ -1,6 +1,11 @@
 require 'rake'
 require 'yaml'
-require 'activesupport'
+begin
+  require 'activesupport'
+rescue LoadError
+  require 'active_support'
+end
+
 # Load a few things to make our lives easier elsewhere.
 module MetricFu
   LIB_ROOT = File.dirname(__FILE__)
@@ -29,4 +34,4 @@ 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}
-Dir[File.join(graph_dir, 'engines', '*.rb')].each {|l| require l}
+Dir[File.join(graph_dir, 'engines', '*.rb')].each {|l| require l}

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

@@ -9,8 +9,8 @@
 <script language="javascript" src="<%= graph_name %>.js?<%= Time.now.to_i %>" type="text/javascript"></script>
 <% end %>
 
-<h2>Total Flog score for all methods: <%= @flog[:total]%></h2>
-<h2>Average Flog score for all methods: <%= @flog[:average]%></h2>
+<h2>Total Flog score for all methods: <%= round_to_tenths @flog[:total]%></h2>
+<h2>Average Flog score for all methods: <%= round_to_tenths @flog[:average]%></h2>
 
 <table>
   <tr>
@@ -20,31 +20,33 @@
     <th>Average score</th>
     <th>Highest score</th>
   </tr>
-    <% @flog[:pages].each do |page| %>
+    <% @flog[:method_containers].each do |method_container| %>
     <tr>
-      <td><a href="#<%= page[:path].gsub(/[^a-z]+/, '_') %>"><%= page[:path] %></a></td>
-      <td><%= page[:score].round %></td>
-      <td><%= page[:scanned_methods].length %></td>
-      <td><%= page[:average_score].round %></td>
-      <td><%= page[:highest_score].round %></td>
+      <td><a href="#<%= method_container[:path].gsub(/[^a-z]+/, '_') %>"><%= method_container[:path] %></a></td>
+      <td><%= round_to_tenths  method_container[:total_score] %></td>
+      <td><%= method_container[:methods].size %></td>
+      <td><%= round_to_tenths method_container[:average_score] %></td>
+      <td><%= round_to_tenths method_container[:highest_score] %></td>
     </tr>
   <% end %>
 </table>
 
-<% @flog[:pages].each do |page| %>
-  <h2 id="<%= page[:path].gsub(/[^a-z]+/, '_') %>"><%= link_to_filename page[:path] %></h2>
-    <% page[:scanned_methods].each do |sm| %>
-      <p><%= link_to_filename(page[:path],sm[:line],sm[:name]) %></p>
-      <p>Total Score: <%=sm[:score]%></p>
+<% @flog[:method_containers].each do |method_container| %>
+  <h2 id="<%= method_container[:path].gsub(/[^a-z]+/, '_') %>"><%= link_to_filename(method_container[:path]) %></h2>
+  
+    <% method_container[:methods].each do |full_method_name, method_info| %>
+      <% path, line = method_info[:path].split(":") if method_info[:path] %>
+      <p><%= link_to_filename(path, line, full_method_name) %></p>
+      <p>Total Score: <%= round_to_tenths method_info[:score]%></p>
       <table>
         <tr>
           <th>Score</th>
           <th>Operator</th>
         </tr>
-        <% sm[:operators].each do |operator| %>
+        <% method_info[:operators].each do |operator, score| %>
           <tr>
-            <td><%= operator[:score] %></td>
-            <td><%= operator[:operator] %></td>
+            <td><%= round_to_tenths score %></td>
+            <td><%= operator %></td>
           </tr>
         <% end %>
       </table>

data/lib/templates/standard/flog.html.erb

@@ -9,45 +9,49 @@
 	<h1>Flog Results</h1>
   <a href="index.html">back to menu</a>
 	<p><a href='http://ruby.sadi.st/Flog.html'>Flog</a> measures code complexity.</p>
-	<h2>Total Flog score for all methods: <%= @flog[:total]%></h2>
-	<h2>Average Flog score for all methods: <%= @flog[:average]%></h2>
-	<table>
-		<tr>
-		  <th>File</th>
-		  <th>Total score</th>
-		  <th>Methods</th>
-		  <th>Average score</th>
-		  <th>Highest score</th>
+  <h2>Total Flog score for all methods: <%= round_to_tenths @flog[:total]%></h2>
+  <h2>Average Flog score for all methods: <%= round_to_tenths @flog[:average]%></h2>
+
+  <table>
+    <tr>
+      <th>File</th>
+      <th>Total score</th>
+      <th>Methods</th>
+      <th>Average score</th>
+      <th>Highest score</th>
     </tr>
-      <% @flog[:pages].each do |page| %>
+      <% @flog[:method_containers].each do |method_container| %>
       <tr>
-        <td><a href="#<%= page[:path].gsub(/[^a-z]+/, '_') %>"><%= page[:path] %></a></td>
-        <td><%= page[:score].round %></td>
-        <td><%= page[:scanned_methods].length %></td>
-        <td><%= page[:average_score].round %></td>
-        <td><%= page[:highest_score].round %></td>
+        <td><a href="#<%= method_container[:path].gsub(/[^a-z]+/, '_') %>"><%= method_container[:path] %></a></td>
+        <td><%= round_to_tenths  method_container[:total_score] %></td>
+        <td><%= method_container[:methods].size %></td>
+        <td><%= round_to_tenths method_container[:average_score] %></td>
+        <td><%= round_to_tenths method_container[:highest_score] %></td>
       </tr>
     <% end %>
   </table>
 
-  <% @flog[:pages].each do |page| %>
-    <h2 id="<%= page[:path].gsub(/[^a-z]+/, '_') %>"><%= page[:path] %></h2>
-      <% page[:scanned_methods].each do |sm| %>
-        <p><%= sm[:name] %></p>
+  <% @flog[:method_containers].each do |method_container| %>
+    <h2 id="<%= method_container[:path].gsub(/[^a-z]+/, '_') %>"><%= link_to_filename(method_container[:path]) %></h2>
+
+      <% method_container[:methods].each do |full_method_name, method_info| %>
+        <% path, line = method_info[:path].split(":") if method_info[:path] %>
+        <p><%= link_to_filename(path, line, full_method_name) %></p>
+        <p>Total Score: <%= round_to_tenths method_info[:score]%></p>
         <table>
           <tr>
             <th>Score</th>
             <th>Operator</th>
           </tr>
-          <% sm[:operators].each do |operator| %>
+          <% method_info[:operators].each do |operator, score| %>
             <tr>
-              <td><%= operator[:score] %></td>
-              <td><%= operator[:operator] %></td>
+              <td><%= round_to_tenths score %></td>
+              <td><%= operator %></td>
             </tr>
           <% end %>
         </table>
       <% end %>
   <% end %>
-	<p>Generated on <%= Time.now.localtime %></p>	
+  <p>Generated on <%= Time.now.localtime %></p>
 </body>
 </html>

data/spec/base/configuration_spec.rb

@@ -97,12 +97,12 @@ describe MetricFu::Configuration do
     
     it 'should set @reek to {:dirs_to_reek => @code_dirs}' do
       @config.instance_variable_get(:@reek).
-              should == {:dirs_to_reek => ['lib']}
+              should == {:config_file_pattern=>nil, :dirs_to_reek => ['lib']}
     end
 
     it 'should set @roodi to {:dirs_to_roodi => @code_dirs}' do
       @config.instance_variable_get(:@roodi).
-              should == {:dirs_to_roodi => ['lib']}
+              should == {:roodi_config=>nil, :dirs_to_roodi => ['lib']}
     end
    
     it 'should set @churn to {}' do

data/spec/base/generator_spec.rb

@@ -156,29 +156,8 @@ describe MetricFu::Generator do
       @concrete_class.should_receive(:to_h)
       @concrete_class.generate_report
     end
-    
-    it "should raise error if the concrete class is missing a required dependency" do
-      concrete_class_with_missing_gem = Class.new(MetricFu::Generator) do
-        def self.verify_dependencies!
-          raise 'gem install something # if you want these tasks'
-        end
-      end
-      lambda { concrete_class_with_missing_gem.generate_report }.should raise_error("gem install something # if you want these tasks")
-    end
 
   end
-  
-  describe "instantiation" do
-    it "should fail is dependencies not verified" do
-      ConcreteClass.should_receive(:verify_dependencies!).and_raise("Missing a required gem. Please 'gem install something'")      
-      lambda { ConcreteClass.new() }.should raise_error("Missing a required gem. Please 'gem install something'")
-    end
-
-    it "should succeed when dependencies verified" do
-      ConcreteClass.should_receive(:verify_dependencies!).and_return(true)
-      ConcreteClass.new()
-    end
-  end
 
   describe "path filter" do
     

data/spec/generators/churn_spec.rb

@@ -6,7 +6,6 @@ describe Churn do
     before :each do
       MetricFu::Configuration.run {}
       File.stub!(:directory?).and_return(true)
-      MetricFu::Churn.should_receive(:verify_dependencies!).and_return(true)
       @changes = {"lib/generators/flog.rb"=>2, "lib/metric_fu.rb"=>3}
     end
     
@@ -30,7 +29,6 @@ describe Churn do
     before :each do
       MetricFu::Configuration.run {}
       File.stub!(:directory?).and_return(true)
-      MetricFu::Churn.should_receive(:verify_dependencies!).and_return(true)
     end
     
     it "should put the changes into a hash" do

data/spec/generators/flay_spec.rb

@@ -1,29 +1,13 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Flay do 
-  before :each do
-    MetricFu::Flay.stub!(:verify_dependencies!).and_return(true)
-  end
   describe "emit method" do
     it "should look at the dirs" do
       MetricFu::Configuration.run {|config| config.flay = { :dirs_to_flay => ['app', 'lib'], :filetypes => ['rb']  } }
       File.stub!(:directory?).and_return(true)
       @flay = MetricFu::Flay.new('base_dir')    
-    
-      Dir.should_receive(:[]).with(File.join("app", "**/*.rb")).and_return("path/to/app")
-      Dir.should_receive(:[]).with(File.join("lib", "**/*.rb")).and_return("path/to/lib")
-      @flay.should_receive(:`).with("flay path/to/app path/to/lib")
-      output = @flay.emit
-    end
 
-    it "should look at the filetypes" do
-      MetricFu::Configuration.run {|config| config.flay = { :dirs_to_flay => ['lib'], :filetypes => ['rb','haml']  } }
-      File.stub!(:directory?).and_return(true)
-      @flay = MetricFu::Flay.new('base_dir')    
-    
-      Dir.should_receive(:[]).with(File.join("lib", "**/*.rb")).and_return("path/to/lib/stuff.rb")
-      Dir.should_receive(:[]).with(File.join("lib", "**/*.haml")).and_return("path/to/lib/view/blah.html.haml")
-      @flay.should_receive(:`).with("flay path/to/lib/stuff.rb path/to/lib/view/blah.html.haml")
+      @flay.should_receive(:`).with("flay  app lib")
       output = @flay.emit
     end
     
@@ -32,7 +16,7 @@ describe Flay do
       File.stub!(:directory?).and_return(true)
       @flay = MetricFu::Flay.new('base_dir')
 
-      @flay.should_receive(:`).with("flay --mass 99 ")
+      @flay.should_receive(:`).with("flay --mass 99  ")
       output = @flay.emit
     end
   end

data/spec/generators/flog_spec.rb

@@ -1,262 +1,70 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 describe Flog do
   before :each do
-    @text = <<-HERE
-    157.9: flog total
-     11.3: flog/method average
-
-     34.8: UsersController#create
-      9.2: branch
-      6.8: current_user
-      5.2: assignment
-      3.4: role
-      3.0: render
-      3.0: ==
-      2.8: flash
-      1.6: after_create_page
-      1.6: params
-      1.5: activate!
-      1.5: errors
-      1.4: login
-      1.4: redirect_to
-      1.4: []
-      1.3: empty?
-      1.3: save
-      1.2: new
-     24.2: UsersController#authorize_user
-      4.8: branch
-      4.7: current_user
-      3.6: params
-      3.2: []
-      2.6: ==
-      1.5: role
-      1.5: to_i
-      1.5: id
-      1.4: new_session_path
-      1.3: include?
-      1.2: assignment
-      1.2: flash
-      1.2: redirect_to
-     16.4: UsersController#thank_you
-      4.0: assignment
-      3.3: params
-      2.9: []
-      2.7: redirect_to
-      2.4: branch
-      1.5: new_session_path
-      1.4: flash
-      1.4: activate!
-      1.3: can_activate?
-      1.2: find_by_id
-     14.2: UsersController#update
-      3.2: params
-      2.8: []
-      2.6: assignment
-      1.4: login
-      1.4: flash
-      1.4: redirect_to
-      1.3: render
-      1.2: branch
-      1.2: update_attributes
-      1.2: find_by_id
-     12.5: UsersController#sanitize_params
-      3.9: assignment
-      3.6: branch
-      3.0: current_user
-      1.6: params
-      1.5: role
-      1.4: []
-      1.3: include?
-      1.3: ==
-      1.2: reject!
-     10.6: UsersController#users_have_changed
-      3.9: assignment
-      2.6: branch
-      1.6: params
-      1.5: refresh_from_external
-      1.4: find_by_id
-      1.4: []
-      1.2: split
-      1.2: each
-      1.2: head
-     10.0: UsersController#after_create_page
-      3.0: current_user
-      2.6: id
-      2.4: branch
-      1.5: role
-      1.3: login
-      1.3: ==
-      8.4: UsersController#add_primary_site
-      2.4: assignment
-      1.6: params
-      1.4: []
-      1.4: new
-      1.2: find_by_id
-      1.2: all
-      1.2: render
-      7.7: UsersController#none
-      3.3: before_filter
-      1.1: private
-      1.1: caches_page
-      1.1: after_filter
-      1.1: skip_before_filter
-      7.2: UsersController#destroy
-      1.8: params
-      1.6: []
-      1.4: find_by_id
-      1.2: destroy
-      1.2: redirect_to
-      5.9: UsersController#edit
-      2.4: assignment
-      1.6: params
-      1.4: []
-      1.2: all
-      1.2: find_by_id
-      2.7: UsersController#signup
-      1.2: render
-      1.2: assignment
-      1.2: new
-      1.7: UsersController#new
-      1.2: assignment
-      1.2: new
-      1.7: UsersController#index
-      1.2: assignment
-      1.2: all
-    HERE
-    MetricFu::Flog.stub!(:verify_dependencies!).and_return(true)
+    MetricFu::Configuration.run {}
+    File.stub!(:directory?).and_return(true)
+    @flog = MetricFu::Flog.new('base_dir')
   end
   
-  describe "parse method" do
-    before :each do
-      MetricFu::Configuration.run {}
-      File.stub!(:directory?).and_return(true)
-      flog = MetricFu::Flog.new('base_dir')
-      @flog_page = flog.parse(@text)
-    end
-    
-    it "should find the total score" do
-      @flog_page.score.should == 157.9
-    end
-    
-    it "should find the average score" do
-      @flog_page.average_score.should == 11.3
-    end
-    
-    it "should find the scanned method score" do
-      @flog_page.scanned_methods.first.score.should == 34.8
-    end
-    
-    it "should find the scanned method name" do
-      @flog_page.scanned_methods.first.name.should == "UsersController#create"
-    end
-    
-    it "should find the scanned method opperators names" do
-      @flog_page.scanned_methods.first.operators.first.operator.should == "branch"
-    end
-    
-    it "should find the scanned method opperators scores" do
-      @flog_page.scanned_methods.first.operators.first.score.should == 9.2
-    end
-    
-    it "should find the name of the method even if namespaced" do
-      text = <<-HERE
-      157.9: flog total
-       11.3: flog/method average
-
-       34.8: SomeNamespace::UsersController#create
-      HERE
-        flog = MetricFu::Flog.new('base_dir')
-        flog_page = flog.parse(text)
-        flog_page.scanned_methods.first.name.should == "SomeNamespace::UsersController#create"
-    end
-
-    it "should find the line number for the method" do
-      text = <<-HERE
-      157.9: flog total
-       11.3: flog/method average
-
-       34.8: SomeNamespace::UsersController#create lib/blah/file.rb:37
-      HERE
-      flog = MetricFu::Flog.new('base_dir')
-      flog_page = flog.parse(text)
-      flog_page.scanned_methods.first.line.should == "37"
-    end
-
-    it "should not add a line number, when none is found" do
-      text = <<-HERE
-      157.9: flog total
-       11.3: flog/method average
-
-       34.8: UsersController#none lib/blah/file.rb
-      HERE
-      flog = MetricFu::Flog.new('base_dir')
-      flog_page = flog.parse(text)
-      flog_page.scanned_methods.first.line.should == nil
-    end
-
-    it "should parse empty flog files" do
-      text = ""
-      flog = MetricFu::Flog.new('base_dir')
-      flog_page = flog.parse(text)
-      flog_page.should be_nil
+  describe "emit method" do
+    it "should look for files and flog them" do
+      Dir.should_receive(:glob).with("lib/**/*.rb").and_return(["found/file.rb"])
+      ::Flog.should_receive(:parse_options).with(["--all", "--details"]).and_return("options")
+      ::Flog.should_receive(:new).with("options").and_return(flogger = mock('flogger'))
+      flogger.should_receive(:flog).with(["found/file.rb"])
+      @flog.emit
     end
   end
   
-  describe "to_h function with results" do
-    before :each do
-      MetricFu::Configuration.run {}
-      File.stub!(:directory?).and_return(true)
-      flog = MetricFu::Flog.new('base_dir')
-      flog.should_receive(:open).and_return(@text)
-      flog.stub!(:is_file_current?).and_return(true)
-      Dir.should_receive(:glob).and_return(["tmp/metric_fu/scratch/flog/app/controllers/user_controller.txt"])
-      flog.analyze
-      @flog_hash = flog.to_h
-    end
-    
-    it "should put the total in the hash" do
-      @flog_hash[:flog][:total].should == 157.9
-    end
-    
-    it "should put the average in the hash" do
-      @flog_hash[:flog][:average].should == 11.3
-    end
-    
-    it "should put pages into the hash" do
-      @flog_hash[:flog][:pages].first[:scanned_methods].first[:score].should == 34.8
-    end
-    
-    it "should put the filename into the hash" do
-      @flog_hash[:flog][:pages].first[:path].should == "/app/controllers/user_controller.rb"
+  describe "analyze method" do
+    it "should harvest the flog information and put it into method_containers" do
+      first_full_method_name = "ClassName#first_method_name"
+      second_full_method_name = "ClassName#second_method_name"
+      
+      flogger = mock('flogger', :calls => {first_full_method_name => {:branch => 11.1, :puts => 1.1},
+                                           second_full_method_name => {:branch => 22.2, :puts => 2.2}}, 
+                                :method_locations => {first_full_method_name => '/file/location.rb:11',
+                                                      second_full_method_name => '/file/location.rb:22'}, 
+                                :totals => {first_full_method_name => 11.11,
+                                            second_full_method_name => 22.22})
+      @flog.instance_variable_set(:@flogger, flogger)
+      @flog.analyze
+      method_containers = @flog.instance_variable_get(:@method_containers)
+      method_containers.size.should == 1
+      
+      expected={:methods=>{"ClassName#first_method_name" => { :path=>"/file/location.rb:11", 
+                                                              :score=>11.11, 
+                                                              :operators=>{ :branch=>11.1, 
+                                                                            :puts=>1.1}},
+                           "ClassName#second_method_name" => {:path=>"/file/location.rb:22", 
+                                                              :score=>22.22, 
+                                                              :operators=>{ :branch=>22.2, 
+                                                                            :puts=>2.2}}}, 
+                :path=>"/file/location.rb",
+                :average_score=>((11.11 + 22.22) / 2.0),
+                :total_score=>33.33,
+                :highest_score=>22.22,
+                :name=>"ClassName"}
+                
+      method_containers["ClassName"].to_h.should == expected
     end
   end
   
-  describe "to_h function ignore files not current" do
-    before :each do
-      MetricFu::Configuration.run {}
-      File.stub!(:directory?).and_return(true)
-      flog = MetricFu::Flog.new('base_dir')
-      flog.should_receive(:open).and_return(@text)
-      flog.stub!(:is_file_current?).and_return(false)
-      Dir.should_receive(:glob).and_return(["tmp/metric_fu/scratch/flog/app/controllers/user_controller.txt"])
-      flog.analyze
-      @flog_hash = flog.to_h
+  describe "to_h method" do
+    it "should make-a nice hash" do
+      flogger = mock('flogger', :total => 111.1, :average => 7.3)
+      @flog.instance_variable_set(:@flogger, flogger)
+      method_containers = {:ignore_me_1 =>  mock('container_1', :highest_score => 11.1, :to_h => 'container_1'),
+                           :ignore_me_2 =>  mock('container_2', :highest_score => 33.3, :to_h => 'container_2'),
+                           :ignore_me_3 =>  mock('container_3', :highest_score => 22.2, :to_h => 'container_3')}
+      @flog.instance_variable_set(:@method_containers, method_containers)
+      
+      expected = {:flog => { :total => 111.1,
+                  :average => 7.3,
+                  :method_containers => ['container_2', 'container_3', 'container_1']}}
+      
+      @flog.to_h.should == expected
     end
     
-    it "should put the total in the hash" do
-      @flog_hash.should == {:flog=>{:total=>0, :pages=>[], :average=>0}}
-    end
-  
-  end
-  
-  describe "to_h function with zero total" do
-    it "should not blow up" do
-      MetricFu::Configuration.run {}
-      File.stub!(:directory?).and_return(true)
-      flog = MetricFu::Flog.new('base_dir')
-      flog.should_receive(:open).and_return("") # some sort of empty or unparsable file
-      Dir.should_receive(:glob).and_return(["empty_file.txt"])
-      flog.analyze
-    end
   end
 end

data/spec/generators/reek_spec.rb

@@ -1,9 +1,19 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Reek do
+  describe "emit" do
+    it "should include config parameters" do
+      MetricFu::Configuration.run do |config|
+        config.reek = {:config_file_pattern => 'lib/config/*.reek', :dirs_to_reek => []}
+      end
+      reek = MetricFu::Reek.new
+      reek.should_receive(:`).with(/--config lib\/config\/\*\.reek/).and_return("")
+      reek.emit
+    end
+  end
+  
   describe "analyze method" do
     before :each do
-      MetricFu::Reek.stub!(:verify_dependencies!).and_return(true)
       @lines = <<-HERE
 "app/controllers/activity_reports_controller.rb" -- 4 warnings:
 ActivityReportsController#authorize_user calls current_user.primary_site_ids multiple times (Duplication)
@@ -61,7 +71,6 @@ end
 
 describe Reek do
   before :each do
-    MetricFu::Reek.stub!(:verify_dependencies!).and_return(true)
     MetricFu::Configuration.run {}
     @reek = MetricFu::Reek.new
     @lines11 = <<-HERE

data/spec/graphs/flog_grapher_spec.rb

@@ -2,8 +2,9 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe MetricFu::FlogGrapher do
   before :each do
-    @flog_grapher = MetricFu::FlogGrapher.new
     MetricFu.configuration
+    @flog_grapher = MetricFu::FlogGrapher.new
+    
   end
   
   it "should respond to flog_total, flog_average and labels" do
@@ -22,18 +23,25 @@ describe MetricFu::FlogGrapher do
   
   describe "responding to #get_metrics" do
     before(:each) do
-      @metrics = YAML::load(File.open(File.join(File.dirname(__FILE__), "..", "resources", "yml", "20090630.yml")))
+      methods = {}
+      100.times do |i|
+        methods["method_name_#{i}"] = {:score => i.to_f}
+      end
+      
+      @metrics = {:flog => {:total => 111.1,
+                            :average => 7.7,
+                            :method_containers => [ {:methods => methods } ] } }
       @date = "1/2"
     end
     
     it "should push to top_five_percent_average" do
-      average = (73.6 + 68.5 + 66.1 + 46.6 + 44.8 + 44.1 + 41.2 + 36.0) / 8.0
+      average = (99.0 + 98.0 + 97.0 + 96.0 + 95.0) / 5.0
       @flog_grapher.top_five_percent_average.should_receive(:push).with(average)      
       @flog_grapher.get_metrics(@metrics, @date)
     end
     
     it "should push 9.9 to flog_average" do
-      @flog_grapher.flog_average.should_receive(:push).with(9.9)
+      @flog_grapher.flog_average.should_receive(:push).with(7.7)
       @flog_grapher.get_metrics(@metrics, @date)
     end
     
@@ -42,4 +50,19 @@ describe MetricFu::FlogGrapher do
       @flog_grapher.get_metrics(@metrics, @date)
     end
   end
+  
+  describe "responding to #get_metrics with legacy data" do
+    before(:each) do
+      @metrics = YAML::load(File.open(File.join(File.dirname(__FILE__), "..", "resources", "yml", "20090630.yml")))
+
+      @date = "1/2"
+    end
+
+    it "should push to top_five_percent_average" do
+      average = (73.6 + 68.5 + 66.1 + 46.6 + 44.8 + 44.1 + 41.2 + 36.0) / 8.0
+      @flog_grapher.top_five_percent_average.should_receive(:push).with(average)      
+      @flog_grapher.get_metrics(@metrics, @date)
+    end
+  end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: metric_fu
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: false
   segments: 
   - 1
-  - 4
+  - 5
   - 0
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors: 
 - Jake Scruggs
@@ -24,7 +24,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-19 00:00:00 -05:00
+date: 2010-07-27 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency