flog 1.2.0 → 2.0.0

data/History.txt

@@ -1,3 +1,17 @@
+=== 2.0.0 / 2009-01-20
+
+* 1 major enhancement:
+
+  * Pulled in and merged Rick Bradley's awesome flame project into flog.
+
+* 1 minor enhancement:
+
+  * Added gauntlet plugin
+
+* 1 bug fix:
+
+  * "hugh sasse".split(/\s/).map{|x|x.capitalize}.join(" ") # :-)
+
 === 1.2.0 / 2008-10-22
 
 * 14 minor enhancements:
@@ -9,7 +23,7 @@
   * Added -q to quiet method details (total per method only)
   * Added avg & stddev to total.
   * Added avg score per method to report.
-  * Added lots of doco from contributors (hugh sasse?).
+  * Added lots of doco from contributors. Thanks Hugh Sasse!
   * Fixed class names when const2/3.
   * Fixed unified ruby changes
   * Refactored flog with help from flay.

data/Manifest.txt

@@ -5,5 +5,22 @@ Rakefile
 bin/flog
 gem_updater.rb
 lib/flog.rb
+lib/gauntlet_flog.rb
 unpack.rb
 update_scores.rb
+spec/flog_command_spec.rb
+spec/flog_integration_spec.rb
+spec/flog_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+spec_fixtures/collection/bigger_example/acts/date_range.rb
+spec_fixtures/collection/bigger_example/acts/range.rb
+spec_fixtures/collection/bigger_example/association_extensions/date_ranged.rb
+spec_fixtures/collection/bigger_example/association_extensions/ranged.rb
+spec_fixtures/collection/bigger_example/reflection_extensions/ranged.rb
+spec_fixtures/directory/bot_filter.rb
+spec_fixtures/directory/bot_parser.rb
+spec_fixtures/directory/bot_parser_format.rb
+spec_fixtures/directory/bot_sender.rb
+spec_fixtures/empty/empty.rb
+spec_fixtures/simple/simple.rb

data/bin/flog

@@ -1,30 +1,59 @@
-#!/usr/local/bin/ruby -ws
+#!/usr/local/bin/ruby -w
 
+require 'optparse'
 require 'flog'
 
-# In case this is being called on the end of a pipe:
+options = {}
+op = OptionParser.new do |opts|
+  opts.on('-a', '--all', "display all flog results, not top 60%") do |a|
+    options[:all] = a
+  end
+
+  opts.on('-s', '--score', 'display total score only')  do |s|
+    options[:score] = s
+  end
+
+  opts.on('-m', '--methods-only', 'skip code outside of methods') do |m|
+    options[:methods] = m
+  end
+
+  opts.on('-n', '--no-details', 'skip method details in report') do |n|
+    options[:no_details] = n
+  end
+
+  opts.on('-c', '--continue', 'continue despite syntax errors') do |c|
+    options[:continue] = c
+  end
+
+  opts.on("-I path1,path2,path3", Array, 'ruby include paths to search') do |i|
+    options[:paths] = i.map { |l| l.to_s }
+  end
+
+  opts.on('-b', '--blame', 'include blame information for methods') do |b|
+    options[:blame] = b
+  end
+
+  opts.on('-v', '--verbose', 'verbosely display progress and errors')  do |v|
+    options[:verbose] = v
+  end
+
+  # TODO: determine difference between -q and -n
+  opts.on('-q', '--quiet', "quiet, don't show method breakdowns")  do |v|
+    options[:quiet] = v
+  end
+
+  opts.on_tail('-h', '--help', 'show this message') do
+    puts opts
+    exit
+  end
+end.parse!
+
+options[:paths].each {|dir| $: << dir } if options[:paths]
+
 ARGV.push "-" if ARGV.empty?
 
-if defined? $h then
-  puts "#{File.basename $0} options dirs_or_files"
-  puts "  -a      display all flog results, not top 60%"
-  puts "  -c      continue despite syntax errors"
-  puts "  -h      display help"
-  puts "  -I=path extend $LOAD_PATH with path"
-  puts "  -m      skip code outside of methods"
-  puts "  -n      no method details in report"
-  puts "  -s      display total score only"
-  puts "  -v      verbosely display progress and errors"
-  puts "  -q      quiet, don't show method breakdowns"
-  exit 0
-end
-
-if defined? $I and String === $I then
-  $I.split(/:/).each do |dir|
-    $: << dir
-  end
-end
-
-flogger = Flog.new
+flogger = Flog.new(options)
 flogger.flog_files ARGV
 flogger.report
+
+exit 0

data/lib/flog.rb

@@ -3,21 +3,13 @@ require 'parse_tree'
 require 'sexp_processor'
 require 'unified_ruby'
 
-$a ||= false # report all methods, not just 60%
-$c ||= false # continue despite syntax errors
-$m ||= false # real methods only (no global scope)
-$n ||= false # no method details
-$s ||= false # summary only
-$v ||= false # verbose, print methods as processed
-$q ||= false # quiet, don't show method details
-
 class Flog < SexpProcessor
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
 
   include UnifiedRuby
 
-  THRESHOLD = $a ? 1.0 : 0.60
-  SCORES = Hash.new(1)
+  THRESHOLD = 0.60
+  SCORES = Hash.new 1
   BRANCHING = [ :and, :case, :else, :if, :or, :rescue, :until, :when, :while ]
 
   ##
@@ -27,6 +19,7 @@ class Flog < SexpProcessor
     :alias          => 2,
     :assignment     => 1,
     :block          => 1,
+    :block_pass     => 1,
     :branch         => 1,
     :lit_fixnum     => 0.25,
     :sclass         => 5,
@@ -74,42 +67,61 @@ class Flog < SexpProcessor
 
   SCORES.merge!(:inject => 2)
 
-  @@no_class = :main
+  @@no_class  = :main
   @@no_method = :none
 
-  attr_reader :calls
+  attr_accessor :multiplier
+  attr_reader :calls, :options, :class_stack, :method_stack
+  attr_reader :total, :average, :stddev
 
-  def initialize
-    super
-    @pt = ParseTree.new(false)
-    @klasses = []
-    @methods = []
-    self.auto_shift_type = true
-    self.require_empty = false # HACK
-    self.reset
+  def add_to_score name, score = OTHER_SCORES[name]
+    @calls["#{klass_name}##{method_name}"][name] += score * @multiplier
   end
 
-  def add_to_score(name, score)
-    @calls["#{self.klass_name}##{self.method_name}"][name] += score * @multiplier
+  ##
+  # Process each element of #exp in turn.
+
+  def analyze_list exp
+    process exp.shift until exp.empty?
   end
 
-  ##
-  # For the duration of the block the complexity factor is increased
-  # by #bonus This allows the complexity of sub-expressions to be
-  # influenced by the expressions in which they are found.  Yields 42
-  # to the supplied block.
+  def average
+    return 0 if calls.size == 0
+    total / calls.size
+  end
 
-  def bad_dog! bonus
-    @multiplier += bonus
-    yield 42
-    @multiplier -= bonus
+  def collect_blame filename # TODO: huh?
   end
 
-  ##
-  # process each element of #exp in turn.
+  def flog ruby, file
+    collect_blame(file) if options[:blame]
+    process_parse_tree(ruby, file)
+  rescue SyntaxError => e
+    if e.inspect =~ /<%|%>/ then
+      warn e.inspect + " at " + e.backtrace.first(5).join(', ')
+      warn "\n...stupid lemmings and their bad erb templates... skipping"
+    else
+      raise e unless options[:continue]
+      warn file
+      warn "#{e.inspect} at #{e.backtrace.first(5).join(', ')}"
+    end
+  end
 
-  def bleed exp
-    process exp.shift until exp.empty?
+  def flog_directory dir
+    Dir["#{dir}/**/*.rb"].each do |file|
+      flog_file(file)
+    end
+  end
+
+  def flog_file file
+    return flog_directory(file) if File.directory? file
+    if file == '-'
+      raise "Cannot provide blame information for code provided on input stream." if options[:blame]
+      data = $stdin.read
+    end
+    data ||= File.read(file)
+    warn "** flogging #{file}" if options[:verbose]
+    flog(data, file)
   end
 
   ##
@@ -118,34 +130,40 @@ class Flog < SexpProcessor
   # There is no way to exclude directories at present (RCS, SCCS, .svn)
   #++
 
-  def flog_files *files
+  def flog_files(*files)
     files.flatten.each do |file|
-      if File.directory? file then
-        flog_files Dir["#{file}/**/*.rb"]
-      else
-        warn "** flogging #{file}" if $v
-        ruby = file == "-" ? $stdin.read : File.read(file)
-        begin
-          sexp = @pt.parse_tree_for_string(ruby, file)
-          process Sexp.from_array(sexp).first
-        rescue SyntaxError => e
-          if e.inspect =~ /<%|%>/ then
-            warn "#{e.inspect} at #{e.backtrace.first(5).join(', ')}"
-            warn "...stupid lemmings and their bad erb templates... skipping"
-          else
-            raise e unless $c
-            warn file
-            warn "#{e.inspect} at #{e.backtrace.first(5).join(', ')}"
-          end
-        end
-      end
+      flog_file(file)
     end
   end
 
-  def klass name
-    @klasses.unshift name
+  def in_klass name
+    @class_stack.unshift name
     yield
-    @klasses.shift
+    @class_stack.shift
+  end
+
+  ##
+  # Adds name to the list of methods, for the duration of the block
+
+  def in_method name
+    @method_stack.unshift name
+    yield
+    @method_stack.shift
+  end
+
+  def increment_total_score_by amount
+    raise "@total_score isn't even set yet... dumbass" unless @total_score
+    @total_score += amount
+  end
+
+  def initialize options = {}
+    super()
+    @options = options
+    @class_stack = []
+    @method_stack = []
+    self.auto_shift_type = true
+    self.require_empty = false # HACK
+    self.reset
   end
 
   ##
@@ -153,107 +171,141 @@ class Flog < SexpProcessor
   # none.
 
   def klass_name
-    name = @klasses.first || @@no_class
+    name = @class_stack.first || @@no_class
     if Sexp === name then
-      case name.first
-      when :colon2 then
-        name = name.flatten
-        name.delete :const
-        name.delete :colon2
-        name = name.join("::")
-      when :colon3 then
-        name = name.last
-      end
+      name = case name.first
+             when :colon2 then
+               name = name.flatten
+               name.delete :const
+               name.delete :colon2
+               name.join("::")
+             when :colon3 then
+               name.last
+             else
+               name
+             end
     end
     name
   end
 
   ##
-  # Adds name to the list of methods, for the duration of the block
+  # returns the first method in the list, or @@no_method if there are
+  # none.
 
-  def method name
-    @methods.unshift name
-    yield
-    @methods.shift
+  def method_name
+    @method_stack.first || @@no_method
+  end
+
+  def output_details(io, max = nil)
+    my_totals = totals
+    current = 0
+    calls.sort_by { |k,v| -my_totals[k] }.each do |class_method, call_list|
+      current += output_method_details(io, class_method, call_list)
+      break if max and current >= max
+    end
+  end
+
+  def output_method_details(io, class_method, call_list)
+    return 0 if options[:methods] and class_method =~ /##{@@no_method}/
+
+    total = totals[class_method]
+    io.puts "%s: (%.1f)" % [class_method, total]
+
+    call_list.sort_by { |k,v| -v }.each do |call, count|
+      io.puts "  %6.1f: %s" % [count, call]
+    end unless options[:no_details] || options[:quiet]
+
+    total
+  end
+
+  def output_summary(io)
+    io.puts "Total Flog = %.1f (%.1f flog / method)\n" % [total, average]
+  end
+
+  def parse_tree
+    @parse_tree ||= ParseTree.new(false)
   end
 
   ##
-  # returns the first method in the list, or @@no_method if there are
-  # none.
+  # For the duration of the block the complexity factor is increased
+  # by #bonus This allows the complexity of sub-expressions to be
+  # influenced by the expressions in which they are found.  Yields 42
+  # to the supplied block.
 
-  def method_name
-    @methods.first || @@no_method
+  def penalize_by bonus
+    @multiplier += bonus
+    yield
+    @multiplier -= bonus
+  end
+
+  def process_parse_tree(ruby, file) # TODO: rename away from process
+    sexp = parse_tree.parse_tree_for_string(ruby, file)
+    process Sexp.from_array(sexp).first
+  end
+
+  def record_method_score(method, score)
+    @totals ||= Hash.new(0)
+    @totals[method] = score
   end
 
   ##
   # Report results to #io, STDOUT by default.
 
-  def report io = $stdout
-    current = 0
-    totals = self.totals
-    total_score = self.total
-    max = total_score * THRESHOLD
-
-    io.puts "Total Flog = %.1f (%.1f +/- %.1f flog / method)" % [total_score, self.average, self.stddev]
-    io.puts
-
-    exit 0 if $s
-
-    @calls.sort_by { |k,v| -totals[k] }.each do |klass_method, calls|
-      next if $m and klass_method =~ /##{@@no_method}/
-      total = totals[klass_method]
-      io.puts "%s: (%.1f)" % [klass_method, total]
-      next if $q
-      calls.sort_by { |k,v| -v }.each do |call, count|
-        io.puts "  %6.1f: %s" % [count, call]
-      end unless $n
-
-      current += total
-      break if current >= max
+  def report(io = $stdout)
+    output_summary(io)
+    return if options[:score]
+
+    if options[:all] then # TODO: fix - use option[:all] and THRESHOLD directly
+      output_details(io)
+    else
+      output_details(io, total * THRESHOLD)
     end
   ensure
     self.reset
   end
 
   def reset
-    # TODO: rename @totals
-    @totals = @total = nil
+    @totals = @total_score = nil
     @multiplier = 1.0
     @calls = Hash.new { |h,k| h[k] = Hash.new 0 }
   end
 
-  attr_reader :total, :average, :stddev
+  def score_method(tally)
+    a, b, c = 0, 0, 0
+    tally.each do |cat, score|
+      case cat
+      when :assignment then a += score
+      when :branch     then b += score
+      else                  c += score
+      end
+    end
+    Math.sqrt(a*a + b*b + c*c)
+  end
+
+  def summarize_method(meth, tally)
+    return if options[:methods] and meth =~ /##{@@no_method}$/
+    score = score_method(tally)
+    record_method_score(meth, score)
+    increment_total_score_by score
+  end
+
+  def total
+    totals unless @total_score # calculates total_score as well
+
+    @total_score
+  end
 
   ##
   # Return the total score and populates @totals.
 
   def totals
     unless @totals then
-      @total = 0
+      @total_score = 0
       @totals = Hash.new(0)
-      self.calls.each do |meth, tally|
-        next if $m and meth =~ /##{@@no_method}$/
-        a, b, c = 0, 0, 0
-        tally.each do |cat, score|
-          case cat
-          when :assignment then a += score
-          when :branch     then b += score
-          else                  c += score
-          end
-        end
-        score = Math.sqrt(a*a + b*b + c*c)
-        @totals[meth] = score
-        @total += score
+      calls.each do |meth, tally|
+        summarize_method(meth, tally)
       end
     end
-
-    size = self.calls.size.to_f
-    @average = @total / size
-
-    sum = 0
-    @totals.values.each { |i| sum += (i - @average) ** 2 }
-    @stddev = (1 / size * sum)
-
     @totals
   end
 
@@ -263,13 +315,13 @@ class Flog < SexpProcessor
   def process_alias(exp)
     process exp.shift
     process exp.shift
-    add_to_score :alias, OTHER_SCORES[:alias]
+    add_to_score :alias
     s()
   end
 
   def process_and(exp)
-    add_to_score :branch, OTHER_SCORES[:branch]
-    bad_dog! 0.1 do
+    add_to_score :branch
+    penalize_by 0.1 do
       process exp.shift # lhs
       process exp.shift # rhs
     end
@@ -278,7 +330,7 @@ class Flog < SexpProcessor
   alias :process_or :process_and
 
   def process_attrasgn(exp)
-    add_to_score :assignment, OTHER_SCORES[:assignment]
+    add_to_score :assignment
     process exp.shift # lhs
     exp.shift # name
     process exp.shift # rhs
@@ -286,77 +338,74 @@ class Flog < SexpProcessor
   end
 
   def process_attrset(exp)
-    add_to_score :assignment, OTHER_SCORES[:assignment]
+    add_to_score :assignment
     raise exp.inspect
     s()
   end
 
   def process_block(exp)
-    bad_dog! 0.1 do
-      bleed exp
+    penalize_by 0.1 do
+      analyze_list exp
     end
     s()
   end
 
   def process_block_pass(exp)
     arg = exp.shift
-    call = exp.shift
 
-    add_to_score :block_pass, OTHER_SCORES[:block]
+    add_to_score :block_pass
 
     case arg.first
     when :lvar, :dvar, :ivar, :cvar, :self, :const, :nil then
       # do nothing
     when :lit, :call then
-      add_to_score :to_proc_normal, OTHER_SCORES[:to_proc_normal]
-    when :iter, *BRANCHING then
-      add_to_score :to_proc_icky!, OTHER_SCORES[:to_proc_icky!]
+      add_to_score :to_proc_normal
+    when :iter, :dsym, :dstr, *BRANCHING then
+      add_to_score :to_proc_icky!
     else
-      raise({:block_pass => [arg, call]}.inspect)
+      raise({:block_pass_even_ickier! => [arg, call]}.inspect)
     end
 
     process arg
-    process call
 
     s()
   end
 
   def process_call(exp)
-    bad_dog! 0.2 do
+    penalize_by 0.2 do
       recv = process exp.shift
     end
     name = exp.shift
-    bad_dog! 0.2 do
+    penalize_by 0.2 do
       args = process exp.shift
     end
 
-    score = SCORES[name]
-    add_to_score name, score
+    add_to_score name, SCORES[name]
 
     s()
   end
 
   def process_case(exp)
-    add_to_score :branch, OTHER_SCORES[:branch]
+    add_to_score :branch
     process exp.shift # recv
-    bad_dog! 0.1 do
-      bleed exp
+    penalize_by 0.1 do
+      analyze_list exp
     end
     s()
   end
 
   def process_class(exp)
-    self.klass exp.shift do
-      bad_dog! 1.0 do
+    in_klass exp.shift do
+      penalize_by 1.0 do
         supr = process exp.shift
       end
-      bleed exp
+      analyze_list exp
     end
     s()
   end
 
   def process_dasgn_curr(exp)
-    add_to_score :assignment, OTHER_SCORES[:assignment]
+    add_to_score :assignment
     exp.shift # name
     process exp.shift # assigment, if any
     s()
@@ -365,24 +414,25 @@ class Flog < SexpProcessor
   alias :process_lasgn :process_dasgn_curr
 
   def process_defn(exp)
-    self.method exp.shift do
-      bleed exp
+    in_method exp.shift do
+      analyze_list exp
     end
     s()
   end
 
   def process_defs(exp)
     process exp.shift
-    self.method exp.shift do
-      bleed exp
+    in_method exp.shift do
+      analyze_list exp
     end
     s()
   end
 
+  # TODO:  it's not clear to me whether this can be generated at all.
   def process_else(exp)
-    add_to_score :branch, OTHER_SCORES[:branch]
-    bad_dog! 0.1 do
-      bleed exp
+    add_to_score :branch
+    penalize_by 0.1 do
+      analyze_list exp
     end
     s()
   end
@@ -390,9 +440,9 @@ class Flog < SexpProcessor
   alias :process_when   :process_else
 
   def process_if(exp)
-    add_to_score :branch, OTHER_SCORES[:branch]
+    add_to_score :branch
     process exp.shift # cond
-    bad_dog! 0.1 do
+    penalize_by 0.1 do
       process exp.shift # true
       process exp.shift # false
     end
@@ -407,21 +457,22 @@ class Flog < SexpProcessor
           [:lit, :str].include? recv.arglist[1][0]) then
         msg = recv[2]
         submsg = recv.arglist[1][1]
-        self.method submsg do
-          self.klass msg do
-            bleed exp
+        in_method submsg do
+          in_klass msg do
+            analyze_list exp
           end
         end
         return s()
       end
     end
 
-    add_to_score :branch, OTHER_SCORES[:branch]
+    add_to_score :branch
 
+    exp.pop if exp.last == 0
     process exp.shift # no penalty for LHS
 
-    bad_dog! 0.1 do
-      bleed exp
+    penalize_by 0.1 do
+      analyze_list exp
     end
 
     s()
@@ -433,7 +484,7 @@ class Flog < SexpProcessor
     when 0, -1 then
       # ignore those because they're used as array indicies instead of first/last
     when Integer then
-      add_to_score :lit_fixnum, OTHER_SCORES[:lit_fixnum]
+      add_to_score :lit_fixnum
     when Float, Symbol, Regexp, Range then
       # do nothing
     else
@@ -443,37 +494,37 @@ class Flog < SexpProcessor
   end
 
   def process_masgn(exp)
-    add_to_score :assignment, OTHER_SCORES[:assignment]
-    bleed exp
+    add_to_score :assignment
+    analyze_list exp
     s()
   end
 
   def process_module(exp)
-    self.klass exp.shift do
-      bleed exp
+    in_klass exp.shift do
+      analyze_list exp
     end
     s()
   end
 
   def process_sclass(exp)
-    bad_dog! 0.5 do
+    penalize_by 0.5 do
       recv = process exp.shift
-      bleed exp
+      analyze_list exp
     end
 
-    add_to_score :sclass, OTHER_SCORES[:sclass]
+    add_to_score :sclass
     s()
   end
 
   def process_super(exp)
-    add_to_score :super, OTHER_SCORES[:super]
-    bleed exp
+    add_to_score :super
+    analyze_list exp
     s()
   end
 
   def process_while(exp)
-    add_to_score :branch, OTHER_SCORES[:branch]
-    bad_dog! 0.1 do
+    add_to_score :branch
+    penalize_by 0.1 do
       process exp.shift # cond
       process exp.shift # body
     end
@@ -483,8 +534,8 @@ class Flog < SexpProcessor
   alias :process_until :process_while
 
   def process_yield(exp)
-    add_to_score :yield, OTHER_SCORES[:yield]
-    bleed exp
+    add_to_score :yield
+    analyze_list exp
     s()
   end
 end