flog 3.2.3 → 4.0.0

data/History.txt

@@ -1,3 +1,16 @@
+=== 4.0.0 / 2013-04-18
+
+* 1 major enhancement:
+
+  * Renamed Flog#methods to #method_scores. (makaroni4)
+
+* 4 minor enhancements:
+
+  * Added accessors for methods, scores. Now available for CIs! (makaroni4)
+  * Refactored calculations down to 2 methods: total_score and totals. (makaroni4)
+  * Refactored to #calculate, #threshold. (makaroni4)
+  * Track stack of nested sclass scopes for parser (pithyless)
+
 === 3.2.3 / 2013-03-21
 
 * 1 bug fix:

data/Manifest.txt

@@ -5,6 +5,8 @@ README.txt
 Rakefile
 bin/flog
 lib/flog.rb
+lib/flog_cli.rb
 lib/flog_task.rb
 lib/gauntlet_flog.rb
 test/test_flog.rb
+test/test_flog_cli.rb

data/Rakefile

@@ -25,14 +25,25 @@ Hoe.spec 'flog' do
 end
 
 task :debug do
-  require "flog"
+  require "flog_cli"
 
-  file = ENV["F"] || "-"
-  ruby = file == "-" ? ENV["R"] : File.read(file)
+  class FlogCLI
+    def_delegators :@flog, :flog_ruby
+  end
 
-  @flog = Flog.new :parser => RubyParser
-  @flog.flog_ruby ruby, file
-  @flog.report
+  file = ENV["F"]
+  ruby = ENV["R"]
+
+  flog = FlogCLI.new :parser => RubyParser
+
+  if file then
+    flog.flog file
+  else
+    flog.flog_ruby ruby, "-"
+    flog.calculate_total_scores
+  end
+
+  flog.report
 end
 
 # vim: syntax=ruby

data/bin/flog

@@ -1,15 +1,14 @@
 #!/usr/local/bin/ruby -w
 
-require 'optparse'
-require 'flog'
+require "flog_cli"
 
-Flog.load_plugins
+FlogCLI.load_plugins
 
-options = Flog.parse_options ARGV
+options = FlogCLI.parse_options ARGV
 
 ARGV << "-" if ARGV.empty?
 
-flogger = Flog.new options
+flogger = FlogCLI.new options
 flogger.flog ARGV
 flogger.report
 

data/lib/flog.rb

@@ -1,11 +1,9 @@
-require 'rubygems'
-require 'sexp_processor'
-require 'ruby_parser'
-require 'optparse'
-require 'timeout'
+require "sexp_processor"
+require "ruby_parser"
+require "timeout"
 
 class File
-  RUBY19 = "<3".respond_to? :encoding unless defined? RUBY19
+  RUBY19 = "<3".respond_to? :encoding unless defined? RUBY19 # :nodoc:
 
   class << self
     alias :binread :read unless RUBY19
@@ -13,10 +11,21 @@ class File
 end
 
 class Flog < SexpProcessor
-  VERSION = "3.2.3"
+  VERSION = "4.0.0" # :nodoc:
+
+  ##
+  # Cut off point where the report should stop unless --all given.
 
   THRESHOLD = 0.60
+
+  ##
+  # The scoring system hash. Maps node type to score.
+
   SCORES = Hash.new 1
+
+  ##
+  # Names of nodes that branch.
+
   BRANCHING = [ :and, :case, :else, :if, :or, :rescue, :until, :when, :while ]
 
   ##
@@ -78,136 +87,13 @@ class Flog < SexpProcessor
   @@no_class  = :main
   @@no_method = :none
 
+  # :stopdoc:
   attr_accessor :multiplier
   attr_reader :calls, :option, :class_stack, :method_stack, :mass, :sclass
-  attr_reader :method_locations
-
-  def self.plugins
-    @plugins ||= {}
-  end
-
-  # TODO: I think I want to do this more like hoe's plugin system. Generalize?
-  def self.load_plugins
-    loaded, found = {}, {}
-
-    Gem.find_files("flog/*.rb").reverse.each do |path|
-      found[File.basename(path, ".rb").intern] = path
-    end
-
-    found.each do |name, plugin|
-      next if loaded[name]
-      begin
-        warn "loading #{plugin}" # if $DEBUG
-        loaded[name] = load plugin
-      rescue LoadError => e
-        warn "error loading #{plugin.inspect}: #{e.message}. skipping..."
-      end
-    end
-
-    self.plugins.merge loaded
-
-    names = Flog.constants.map {|s| s.to_s}.reject {|n| n =~ /^[A-Z_]+$/}
-
-    names.each do |name|
-      # next unless Hoe.plugins.include? name.downcase.intern
-      mod = Flog.const_get(name)
-      next if Class === mod
-      warn "extend #{mod}" if $DEBUG
-      # self.extend mod
-    end
-  end
-
-  # REFACTOR: from flay
-  def self.expand_dirs_to_files *dirs
-    extensions = %w[rb rake]
-
-    dirs.flatten.map { |p|
-      if File.directory? p then
-        Dir[File.join(p, '**', "*.{#{extensions.join(',')}}")]
-      else
-        p
-      end
-    }.flatten.sort
-  end
-
-  def self.parse_options args = ARGV
-    option = {
-      :quiet    => false,
-      :continue => false,
-      :parser   => RubyParser,
-    }
-
-    OptionParser.new do |opts|
-      opts.separator "Standard options:"
-
-      opts.on("-a", "--all", "Display all flog results, not top 60%.") do
-        option[:all] = true
-      end
-
-      opts.on("-b", "--blame", "Include blame information for methods.") do
-        option[:blame] = true
-      end
-
-      opts.on("-c", "--continue", "Continue despite syntax errors.") do
-        option[:continue] = true
-      end
-
-      opts.on("-d", "--details", "Show method details.") do
-        option[:details] = true
-      end
-
-      opts.on("-g", "--group", "Group and sort by class.") do
-        option[:group] = true
-      end
-
-      opts.on("-h", "--help", "Show this message.") do
-        puts opts
-        exit
-      end
-
-      opts.on("-I dir1,dir2,dir3", Array, "Add to LOAD_PATH.") do |dirs|
-        dirs.each do |dir|
-          $: << dir
-        end
-      end
-
-      opts.on("-m", "--methods-only", "Skip code outside of methods.") do
-        option[:methods] = true
-      end
-
-      opts.on("-q", "--quiet", "Don't show parse errors.") do
-        option[:quiet] = true
-      end
-
-      opts.on("-s", "--score", "Display total score only.") do
-        option[:score] = true
-      end
-
-      opts.on("-v", "--verbose", "Display progress during processing.") do
-        option[:verbose] = true
-      end
-
-      opts.on("--18", "Use a ruby 1.8 parser.") do
-        option[:parser] = Ruby18Parser
-      end
-
-      opts.on("--19", "Use a ruby 1.9 parser.") do
-        option[:parser] = Ruby19Parser
-      end
-
-      next if self.plugins.empty?
-      opts.separator "Plugin options:"
-
-      extra = self.methods.grep(/parse_options/) - %w(parse_options)
-
-      extra.sort.each do |msg|
-        self.send msg, opts, option
-      end
-
-    end.parse! Array(args)
+  attr_reader :method_locations, :method_scores, :scores
+  attr_reader :total_score, :totals
 
-    option
-  end
+  # :startdoc:
 
   ##
   # Add a score to the tally. Score can be predetermined or looked up
@@ -223,18 +109,44 @@ class Flog < SexpProcessor
 
   def average
     return 0 if calls.size == 0
-    total / calls.size
+    total_score / calls.size
+  end
+
+  ##
+  # Calculates classes and methods scores.
+
+  def calculate
+    each_by_score threshold do |class_method, score, call_list|
+      klass = class_method.split(/#|::/).first
+
+      method_scores[klass] << [class_method, score]
+      scores[klass] += score
+    end
+  end
+
+  ##
+  # Returns true if the form looks like a "DSL" construct.
+  #
+  #   task :blah do ... end
+  #   => s(:iter, s(:call, nil, :task, s(:lit, :blah)), ...)
+
+  def dsl_name? args
+    return false unless args and not args.empty?
+
+    first_arg = args.first
+    first_arg = first_arg[1] if first_arg[0] == :hash
+
+    [:lit, :str].include? first_arg[0] and first_arg[1]
   end
 
   ##
   # Iterate over the calls sorted (descending) by score.
 
   def each_by_score max = nil
-    my_totals = totals
-    current   = 0
+    current = 0
 
-    calls.sort_by { |k,v| -my_totals[k] }.each do |class_method, call_list|
-      score = my_totals[class_method]
+    calls.sort_by { |k,v| -totals[k] }.each do |class_method, call_list|
+      score = totals[class_method]
 
       yield class_method, score, call_list
 
@@ -244,12 +156,12 @@ class Flog < SexpProcessor
   end
 
   ##
-  # Flog the given files or directories. Smart. Deals with "-", syntax
-  # errors, and traversing subdirectories intelligently.
-
-  def flog(*files_or_dirs)
-    files = Flog.expand_dirs_to_files(*files_or_dirs)
+  # Flog the given files. Deals with "-", and syntax errors.
+  #
+  # Not as smart as FlogCLI's #flog method as it doesn't traverse
+  # dirs. Use FlogCLI.expand_dirs_to_files or see FlogCLI#flog.
 
+  def flog(*files)
     files.each do |file|
       next unless file == '-' or File.readable? file
 
@@ -257,6 +169,8 @@ class Flog < SexpProcessor
 
       flog_ruby ruby, file
     end
+
+    calculate_total_scores
   end
 
   ##
@@ -337,10 +251,13 @@ class Flog < SexpProcessor
     @method_stack.shift
   end
 
+  ##
+  # Creates a new Flog instance with +options+.
+
   def initialize option = {}
     super()
     @option              = option
-    @sclass              = nil
+    @sclass              = []
     @class_stack         = []
     @method_stack        = []
     @method_locations    = {}
@@ -367,60 +284,27 @@ class Flog < SexpProcessor
   end
 
   ##
-  # Returns the first method in the list, or "#none" if there are
-  # none.
+  # Returns the method/score pair of the maximum score.
 
-  def method_name
-    m = @method_stack.first || @@no_method
-    m = "##{m}" unless m =~ /::/
-    m
+  def max_method
+    totals.max_by { |_, score| score }
   end
 
   ##
-  # Output the report up to a given max or report everything, if nil.
-
-  def output_details io, max = nil
-    io.puts
+  # Returns the maximum score for a single method. Used for FlogTask.
 
-    each_by_score max do |class_method, score, call_list|
-      return 0 if option[:methods] and class_method =~ /##{@@no_method}/
-
-      self.print_score io, class_method, score
-
-      if option[:details] then
-        call_list.sort_by { |k,v| -v }.each do |call, count|
-          io.puts "  %6.1f:   %s" % [count, call]
-        end
-        io.puts
-      end
-    end
-    # io.puts
+  def max_score
+    max_method.last
   end
 
   ##
-  # Output the report, grouped by class/module, up to a given max or
-  # report everything, if nil.
-
-  def output_details_grouped io, max = nil
-    scores  = Hash.new 0
-    methods = Hash.new { |h,k| h[k] = [] }
-
-    each_by_score max do |class_method, score, call_list|
-      klass = class_method.split(/#|::/).first
-
-      methods[klass] << [class_method, score]
-      scores[klass]  += score
-    end
-
-    scores.sort_by { |_, n| -n }.each do |klass, total|
-      io.puts
-
-      io.puts "%8.1f: %s" % [total, "#{klass} total"]
+  # Returns the first method in the list, or "#none" if there are
+  # none.
 
-      methods[klass].each do |name, score|
-        self.print_score io, name, score
-      end
-    end
+  def method_name
+    m = @method_stack.first || @@no_method
+    m = "##{m}" unless m =~ /::/
+    m
   end
 
   ##
@@ -435,18 +319,6 @@ class Flog < SexpProcessor
     @multiplier -= bonus
   end
 
-  ##
-  # Print out one formatted score.
-
-  def print_score io, name, score
-    location = @method_locations[name]
-    if location then
-      io.puts "%8.1f: %-32s %s" % [score, name, location]
-    else
-      io.puts "%8.1f: %s" % [score, name]
-    end
-  end
-
   ##
   # Process each element of #exp in turn.
 
@@ -454,32 +326,15 @@ class Flog < SexpProcessor
     process exp.shift until exp.empty?
   end
 
-  ##
-  # Report results to #io, STDOUT by default.
-
-  def report(io = $stdout)
-    io.puts "%8.1f: %s" % [total, "flog total"]
-    io.puts "%8.1f: %s" % [average, "flog/method average"]
-
-    return if option[:score]
-
-    max = option[:all] ? nil : total * THRESHOLD
-    if option[:group] then
-      output_details_grouped io, max
-    else
-      output_details io, max
-    end
-  ensure
-    self.reset
-  end
-
   ##
   # Reset score data
 
   def reset
-    @totals     = @total_score = nil
-    @multiplier = 1.0
-    @calls      = Hash.new { |h,k| h[k] = Hash.new 0 }
+    @totals        = @total_score = nil
+    @multiplier    = 1.0
+    @calls         = Hash.new { |h,k| h[k] = Hash.new 0 }
+    @method_scores = Hash.new { |h,k| h[k] = [] }
+    @scores        = Hash.new 0
   end
 
   ##
@@ -497,47 +352,46 @@ class Flog < SexpProcessor
     Math.sqrt(a*a + b*b + c*c)
   end
 
+  ##
+  # Returns the method signature for the current method.
+
   def signature
     "#{klass_name}#{method_name}"
   end
 
-  def total # FIX: I hate this indirectness
-    totals unless @total_score # calculates total_score as well
-
-    @total_score
-  end
-
-  def max_score
-    max_method.last
-  end
+  ##
+  # Final threshold that is used for report
 
-  def max_method
-    totals.max_by { |_, score| score }
+  def threshold
+    option[:all] ? nil : total_score * THRESHOLD
   end
 
   ##
-  # Return the total score and populates @totals.
+  # Calculates the total score and populates @totals.
 
-  def totals
-    unless @totals then
-      @total_score = 0
-      @totals = Hash.new(0)
+  def calculate_total_scores
+    return if @totals
 
-      calls.each do |meth, tally|
-        next if option[:methods] and meth =~ /##{@@no_method}$/
-        score = score_method(tally)
+    @total_score = 0
+    @totals = Hash.new(0)
 
-        @totals[meth] = score
-        @total_score += score
-      end
+    calls.each do |meth, tally|
+      next if option[:methods] and meth =~ /##{@@no_method}$/
+      score = score_method(tally)
+
+      @totals[meth] = score
+      @total_score += score
     end
+  end
 
-    @totals
+  def no_method # :nodoc:
+    @@no_method
   end
 
   ############################################################
   # Process Methods:
 
+  # :stopdoc:
   def process_alias(exp)
     process exp.shift
     process exp.shift
@@ -642,7 +496,7 @@ class Flog < SexpProcessor
   alias :process_lasgn :process_dasgn_curr
 
   def process_defn(exp)
-    name = @sclass ? "::#{exp.shift}" : exp.shift
+    name = @sclass.empty? ? exp.shift : "::#{exp.shift}"
     in_method name, exp.file, exp.line do
       process_until_empty exp
     end
@@ -678,15 +532,6 @@ class Flog < SexpProcessor
     s()
   end
 
-  def dsl_name? args
-    return false unless args and not args.empty?
-
-    first_arg = args.first
-    first_arg = first_arg[1] if first_arg[0] == :hash
-
-    [:lit, :str].include? first_arg[0] and first_arg[1]
-  end
-
   def process_iter(exp)
     context = (self.context - [:class, :module, :scope])
     context = context.uniq.sort_by { |s| s.to_s }
@@ -758,12 +603,12 @@ class Flog < SexpProcessor
   end
 
   def process_sclass(exp)
-    @sclass = true
+    @sclass.push(true)
     penalize_by 0.5 do
       process exp.shift # recv
       process_until_empty exp
     end
-    @sclass = nil
+    @sclass.pop
 
     add_to_score :sclass
     s()
@@ -791,4 +636,5 @@ class Flog < SexpProcessor
     process_until_empty exp
     s()
   end
+  # :startdoc:
 end