flog 1.0.2 → 1.1.0

data/History.txt

@@ -1,3 +1,27 @@
+== 1.1.0 / 2007-08-21
+
+* 3 major enhancements:
+  * Added assignments and branches and a lot of other stuff. rad.
+  * Added process_iter section for DSL style blocks (rake tasks etc).
+  * Made Flog usable as a library.
+* 12 minor enhancements:
+  * Added -a flag to turn off threshold culling for other tools.
+  * Added -s for summarizing the score.
+  * Added -v feedback to know what file you're flogging.
+  * Added branching penalty so tons of nested conditionals get beat down.
+  * Added send (3).
+  * Capture and ignore SyntaxErrors from template/generator code. Stupid DHH.
+  * Report can now take an IO object.
+  * block_args now penalizes all non-benign forms of block_pass. 
+  * Added usage to bin/flog. Moved -I processing to bin/flog.
+  * Added unpack.rb and update_scores.rb at base level (not installed)
+  * Added scoring for block_pass.
+  * Converted totals to use distance formula on ABC's.
+* 3 bug fixes:
+  * Ran flog on every latest gem available. Found a bunch of problems.
+  * Use a stack for both class/module and method accounting.
+  * block_args weren't processing the arg
+
 == 1.0.2 / 2007-08-01
 
 * 1 bug fix:

data/Manifest.txt

@@ -4,3 +4,5 @@ README.txt
 Rakefile
 bin/flog
 lib/flog.rb
+unpack.rb
+update_scores.rb

data/README.txt

@@ -1,6 +1,6 @@
 flog
     by Ryan Davis, Seattle.rb
-    http://seattlerb.rubyforge.org/
+    http://ruby.sadi.st/
     http://rubyforge.org/projects/seattlerb
 
 == DESCRIPTION:

data/Rakefile

@@ -8,7 +8,7 @@ Hoe.new('flog', Flog::VERSION) do |p|
   p.rubyforge_name = 'seattlerb'
   p.summary = p.paragraphs_of('README.txt', 2).first
   p.description = p.paragraphs_of('README.txt', 2, 6).join("\n\n")
-  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/).last.strip
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[2..-1].map {|u| u.strip }
   p.changes = p.paragraphs_of('History.txt', 1).join("\n\n")
 
   p.extra_deps << ["ParseTree", '>= 2.0.0']

data/bin/flog

@@ -1,7 +1,25 @@
-#!/usr/local/bin/ruby -w
+#!/usr/local/bin/ruby -ws
 
 require 'flog'
 
+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 "  -h      display help"
+  puts "  -I=path extend $LOAD_PATH with path"
+  puts "  -s      display total score only"
+  puts "  -v      verbosely display progress and errors"
+  exit 0
+end
+
+if defined? $I and String === $I then
+  $I.split(/:/).each do |dir|
+    $: << dir
+  end
+end
+
 flogger = Flog.new
-flogger.process_files ARGV
+flogger.flog_files ARGV
 flogger.report

data/lib/flog.rb

@@ -3,24 +3,44 @@ require 'parse_tree'
 require 'sexp_processor'
 require 'unified_ruby'
 
+$a ||= false
+$s ||= false
+$v ||= false
+
 class Flog < SexpProcessor
-  VERSION = '1.0.2'
+  VERSION = '1.1.0'
 
   include UnifiedRuby
 
-  THRESHOLD = 0.60
-
+  THRESHOLD = $a ? 1.0 : 0.60
   SCORES = Hash.new(1)
+  BRANCHING = [ :and, :case, :else, :if, :or, :rescue, :until, :when, :while ]
 
+  # various non-call constructs
+  OTHER_SCORES = {
+    :alias => 2,
+    :assignment => 1,
+    :block => 1,
+    :branch => 1,
+    :lit_fixnum => 0.25,
+    :sclass => 5,
+    :super => 1,
+    :to_proc_icky! => 10,
+    :to_proc_normal => 5,
+    :yield => 1,
+  }
+
+  # eval forms
   SCORES.merge!(:define_method => 5,
                 :eval => 5,
                 :module_eval => 5,
                 :class_eval => 5,
                 :instance_eval => 5)
 
+  # various "magic" usually used for "clever code"
   SCORES.merge!(:alias_method => 2,
-                :include => 2,
                 :extend => 2,
+                :include => 2,
                 :instance_method => 2,
                 :instance_methods => 2,
                 :method_added => 2,
@@ -36,63 +56,142 @@ class Flog < SexpProcessor
                 :public_instance_methods => 2,
                 :public_method_defined? => 2,
                 :remove_method => 2,
+                :send => 3,
                 :undef_method => 2)
 
-  @@no_class = :none
+  # calls I don't like and usually see being abused
+  SCORES.merge!(:inject => 2)
+
+  @@no_class = :main
   @@no_method = :none
 
+  attr_reader :calls
+
   def initialize
     super
     @pt = ParseTree.new(false)
-    @klass_name, @method_name = @@no_class, @@no_method
+    @klasses = []
+    @methods = []
     self.auto_shift_type = true
     self.require_empty = false # HACK
-    @totals = Hash.new 0
-    @multiplier = 1.0
+    self.reset
+  end
 
-    @calls = Hash.new { |h,k| h[k] = Hash.new 0 }
+  def add_to_score(name, score)
+    @calls["#{self.klass_name}##{self.method_name}"][name] += score * @multiplier
+  end
+
+  def bad_dog! bonus
+    @multiplier += bonus
+    yield 42
+    @multiplier -= bonus
   end
 
-  def process_files *files
+  def bleed exp
+    process exp.shift until exp.empty?
+  end
+
+  def flog_files *files
     files.flatten.each do |file|
-      next unless File.file? file or file == "-"
-      ruby = file == "-" ? $stdin.read : File.read(file)
-      sexp = @pt.parse_tree_for_string(ruby, file)
-      process Sexp.from_array(sexp)
+      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
+          end
+        end
+      end
     end
   end
 
-  def report
-    total_score = @totals.values.inject(0) { |sum,n| sum + n }
-    max = total_score * THRESHOLD
+  def klass name
+    @klasses.unshift name
+    yield
+    @klasses.shift
+  end
+
+  def klass_name
+    @klasses.first || @@no_class
+  end
+
+  def method name
+    @methods.unshift name
+    yield
+    @methods.shift
+  end
+
+  def method_name
+    @methods.first || @@no_method
+  end
+
+  def report io = $stdout
     current = 0
+    total_score = self.total
+    max = total_score * THRESHOLD
+    totals = self.totals
 
-    puts "Total score = #{total_score}"
-    puts
+    if $s then
+      io.puts total_score
+      exit 0
+    end
+
+    io.puts "Total score = #{total_score}"
+    io.puts
 
-    @calls.sort_by { |k,v| -@totals[k] }.each do |klass_method, calls|
-      total = @totals[klass_method]
-      puts "%s: (%d)" % [klass_method, total]
+    @calls.sort_by { |k,v| -totals[k] }.each do |klass_method, calls|
+      total = totals[klass_method]
+      io.puts "%s: (%.1f)" % [klass_method, total]
       calls.sort_by { |k,v| -v }.each do |call, count|
-        puts "  %4d: %s" % [count, call]
+        io.puts "  %6.1f: %s" % [count, call]
       end
 
       current += total
       break if current >= max
     end
-  rescue
-    # do nothing
+  ensure
+    self.reset
   end
 
-  def add_to_score(name, score)
-    @totals["#{@klass_name}##{@method_name}"] += score * @multiplier
-    @calls["#{@klass_name}##{@method_name}"][name] += score * @multiplier
+  def reset
+    @totals = @total_score = nil
+    @multiplier = 1.0
+    @calls = Hash.new { |h,k| h[k] = Hash.new 0 }
   end
 
-  def bad_dog! bonus
-    @multiplier += bonus
-    yield
-    @multiplier -= bonus
+  def total
+    self.totals unless @total_score # calculates total_score as well
+
+    @total_score
+  end
+
+  def totals
+    unless @totals then
+      @total_score = 0
+      @totals = Hash.new(0)
+      self.calls.each do |meth, 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
+        score = Math.sqrt(a*a + b*b + c*c)
+        @totals[meth] = score
+        @total_score += score
+      end
+    end
+    @totals
   end
 
   ############################################################
@@ -101,7 +200,37 @@ class Flog < SexpProcessor
   def process_alias(exp)
     process exp.shift
     process exp.shift
-    add_to_score :alias, 2
+    add_to_score :alias, OTHER_SCORES[:alias]
+    s()
+  end
+
+  def process_and(exp)
+    add_to_score :branch, OTHER_SCORES[:branch]
+    bad_dog! 0.1 do
+      process exp.shift # lhs
+      process exp.shift # rhs
+    end
+    s()
+  end
+
+  def process_attrasgn(exp)
+    add_to_score :assignment, OTHER_SCORES[:assignment]
+    process exp.shift # lhs
+    exp.shift # name
+    process exp.shift # rhs
+    s()
+  end
+
+  def process_attrset(exp)
+    add_to_score :assignment, OTHER_SCORES[:assignment]
+    raise exp.inspect
+    s()
+  end
+
+  def process_block(exp)
+    bad_dog! 0.1 do
+      bleed exp
+    end
     s()
   end
 
@@ -110,18 +239,22 @@ class Flog < SexpProcessor
     arg = exp.shift
     call = exp.shift
 
+    add_to_score :block_pass, OTHER_SCORES[:block]
+
     case arg.first
-    when :iter then
-      add_to_score :to_proc_iter_wtf?, 6
-    when :lit, :call, :iter then
-      add_to_score :to_proc, 3
-    when :lvar, :dvar, :ivar, :nil then
+    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!]
     else
-      raise({:block_pass => [call, arg]}.inspect)
+      raise({:block_pass => [arg, call]}.inspect)
     end
 
-    call = process call
+    process arg
+    process call
+
     s()
   end
 
@@ -140,30 +273,103 @@ class Flog < SexpProcessor
     s()
   end
 
-  def process_class(exp)
-    @klass_name = exp.shift
-    bad_dog! 1.0 do
-      supr = process exp.shift
+  def process_case(exp)
+    add_to_score :branch, OTHER_SCORES[:branch]
+    process exp.shift # recv
+    bad_dog! 0.1 do
+      bleed exp
     end
-    until exp.empty?
-      process exp.shift
+    s()
+  end
+
+  def process_class(exp)
+    self.klass exp.shift do
+      bad_dog! 1.0 do
+        supr = process exp.shift
+      end
+      bleed exp
     end
-    @klass_name = @@no_class
+    s()
+  end
+
+  def process_dasgn_curr(exp)
+    add_to_score :assignment, OTHER_SCORES[:assignment]
+    exp.shift # name
+    process exp.shift # assigment, if any
     s()
   end
 
   def process_defn(exp)
-    @method_name = exp.shift
-    process exp.shift until exp.empty?
-    @method_name = @@no_method
+    self.method exp.shift do
+      bleed exp
+    end
     s()
   end
 
   def process_defs(exp)
     process exp.shift
-    @method_name = exp.shift
-    process exp.shift until exp.empty?
-    @method_name = @@no_method
+    self.method exp.shift do
+      bleed exp
+    end
+    s()
+  end
+
+  def process_else(exp)
+    add_to_score :branch, OTHER_SCORES[:branch]
+    bad_dog! 0.1 do
+      bleed exp
+    end
+    s()
+  end
+
+  def process_iasgn(exp)
+    add_to_score :assignment, OTHER_SCORES[:assignment]
+    exp.shift # name
+    process exp.shift # rhs
+    s()
+  end
+
+  def process_if(exp)
+    add_to_score :branch, OTHER_SCORES[:branch]
+    process exp.shift # cond
+    bad_dog! 0.1 do
+      process exp.shift # true
+      process exp.shift # false
+    end
+    s()
+  end
+
+  def process_iter(exp)
+    context = (self.context - [:class, :module, :scope])
+    if context.uniq.sort_by {|s|s.to_s} == [:block, :iter] then
+      recv = exp.first
+      if recv[0] == :call and recv[1] == nil and recv.arglist[1] and [: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
+          end
+        end
+        return s()
+      end
+    end
+
+    add_to_score :branch, OTHER_SCORES[:branch]
+
+    process exp.shift # no penalty for LHS
+
+    bad_dog! 0.1 do
+      bleed exp
+    end
+
+    s()
+  end
+
+  def process_lasgn(exp)
+    add_to_score :assignment, OTHER_SCORES[:assignment]
+    exp.shift # name
+    process exp.shift # rhs
     s()
   end
 
@@ -173,7 +379,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, 0.25
+      add_to_score :lit_fixnum, OTHER_SCORES[:lit_fixnum]
     when Float, Symbol, Regexp, Range then
       # do nothing
     else
@@ -182,22 +388,84 @@ class Flog < SexpProcessor
     s()
   end
 
+  def process_masgn(exp)
+    add_to_score :assignment, OTHER_SCORES[:assignment]
+    process exp.shift # lhs
+    process exp.shift # rhs
+    s()
+  end
+
   def process_module(exp)
-    @klass_name = exp.shift
-    until exp.empty?
-      process exp.shift
+    self.klass exp.shift do
+      bleed exp
+    end
+    s()
+  end
+
+  def process_or(exp)
+    add_to_score :branch, OTHER_SCORES[:branch]
+    bad_dog! 0.1 do
+      process exp.shift # lhs
+      process exp.shift # rhs
+    end
+    s()
+  end
+
+  def process_rescue(exp)
+    add_to_score :branch, OTHER_SCORES[:branch]
+    bad_dog! 0.1 do
+      bleed exp
     end
-    @klass_name = @@no_class
     s()
   end
 
   def process_sclass(exp)
     bad_dog! 0.5 do
       recv = process exp.shift
-      process exp.shift until exp.empty?
+      bleed exp
+    end
+
+    add_to_score :sclass, OTHER_SCORES[:sclass]
+    s()
+  end
+
+  def process_super(exp)
+    add_to_score :super, OTHER_SCORES[:super]
+    bleed exp
+    s()
+  end
+
+  def process_until(exp)
+    add_to_score :branch, OTHER_SCORES[:branch]
+    bad_dog! 0.1 do
+      process exp.shift # cond
+      process exp.shift # body
+    end
+    exp.shift # pre/post
+    s()
+  end
+
+  def process_when(exp)
+    add_to_score :branch, OTHER_SCORES[:branch]
+    bad_dog! 0.1 do
+      bleed exp
+    end
+    s()
+  end
+
+  def process_while(exp)
+    add_to_score :branch, OTHER_SCORES[:branch]
+    bad_dog! 0.1 do
+      process exp.shift # cond
+      process exp.shift # body
     end
+    exp.shift # pre/post
+    s()
+  end
 
-    add_to_score :sclass, 5
+  def process_yield(exp)
+    add_to_score :yield, OTHER_SCORES[:yield]
+    bleed exp
     s()
   end
 end

data/unpack.rb

@@ -0,0 +1,22 @@
+#!/usr/local/bin/ruby -w
+
+code = '../code'
+
+pattern = ARGV.empty? ? nil : Regexp.union(*ARGV)
+
+Dir.mkdir code unless File.directory? code
+
+Dir.chdir code do
+  Dir["../gems/*.gem"].each do |gem|
+    project = File.basename gem
+    next unless project =~ pattern if pattern
+    dir = project.sub(/\.gem$/, '')
+    warn dir
+    unless File.directory? dir then
+      Dir.mkdir dir
+      Dir.chdir dir do
+        system "(tar -Oxf ../#{gem} data.tar.gz | tar zxf -) 2> /dev/null"
+      end
+    end
+  end
+end

data/update_scores.rb

@@ -0,0 +1,238 @@
+#!/usr/local/bin/ruby -ws
+
+$: << 'lib'
+$: << '../../ParseTree/dev/lib'
+require 'flog'
+require 'rubygems/source_info_cache'
+
+$u ||= false
+$f ||= false
+
+$score_file = '../dev/scores.yml'
+$misc_error = [-1]
+$syntax_error = [-2]
+$no_methods = ["", -3]
+$no_gem = [-4]
+
+max = (ARGV.shift || 10).to_i
+
+scores = YAML.load(File.read($score_file)) rescue {}
+
+["ruby-aes-table1-1.0.gem",
+ "ruby-aes-unroll1-1.0.gem",
+ "hpricot-scrub-0.2.0.gem",
+ "extract_curves-0.0.1.gem",
+ "rfeedparser-ictv-0.9.931.gem",
+ "spec_unit-0.0.1.gem"].each do|p|
+  scores[p] = $no_gem.dup
+end
+
+Dir.mkdir "../gems" unless File.directory? "../gems"
+
+if $u then
+  puts "updating mirror"
+
+  Dir.chdir "../gems" do
+    cache = Gem::SourceInfoCache.cache_data['http://gems.rubyforge.org']
+
+    gems = Dir["*.gem"]
+    old = gems - cache.source_index.latest_specs.values.map { |spec|
+      "#{spec.full_name}.gem"
+    }
+
+    puts "deleting #{old.size} gems"
+    old.each do |gem|
+      scores.delete gem
+      File.unlink gem
+    end
+
+    new = cache.source_index.latest_specs.map { |name, spec|
+      "#{spec.full_name}.gem"
+    } - gems
+
+    puts "fetching #{new.size} gems"
+    new.each do |gem|
+      next if scores[gem] == $no_gem unless $f # FIX
+      unless system "wget http://gems.rubyforge.org/gems/#{gem}" then
+        scores[gem] = $no_gem
+      end
+    end
+  end
+end
+
+my_projects = Regexp.union("InlineFortran", "ParseTree", "RubyInline", "ZenTest", "bfts", "box_layout", "flog", "heckle", "image_science", "miniunit", "png", "ruby2ruby", "vlad", "zentest", "ZenHacks", "rubyforge", "RubyToC", "hoe")
+
+$owners = {}
+cache = Marshal.load(File.read(Gem::SourceInfoCache.new.cache_file))
+cache['http://gems.rubyforge.org'].source_index.latest_specs.map { |name, spec|
+  owner = spec.authors.compact
+  owner = Array(spec.email) if owner.empty?
+  owner.map! { |o| o.sub(/\s*[^ \w@.].*$/, '') }
+  owner = ["NOT Ryan Davis"] if owner.include? "Ryan Davis" and name !~ my_projects
+
+  # because we screwed these up back before hoe
+  owner << "Eric Hodel" if name =~ /bfts|RubyToC|ParseTree|heckle/
+
+  $owners["#{spec.full_name}.gem"] = owner.uniq
+}
+
+def score_for dir
+  files = `find #{dir} -name \\*.rb | grep -v gen.*templ`.split(/\n/)
+
+  flogger = Flog.new
+  flogger.flog_files files
+  methods = flogger.totals.reject { |k,v| k =~ /\#none$/ }.sort_by { |k,v| v }
+  methods = [$no_methods.dup] if methods.empty?
+  [flogger.total] + methods
+rescue SyntaxError => e
+  warn e.inspect + " at " + e.backtrace.first(5).join(', ') if $v
+  $syntax_error.dup
+rescue => e
+  warn e.inspect + " at " + e.backtrace.first(5).join(', ') if $v
+  $misc_error.dup
+end
+
+def save_scores scores
+  File.open("#{$score_file}.new", 'w') do |f|
+    warn "*** saving scores"
+    YAML.dump scores, f
+  end
+  File.rename "#{$score_file}.new", $score_file
+end
+
+begin
+  dirty = false
+  Dir.chdir "../gems" do
+    Dir["*.gem"].each_with_index do |gem, i|
+      project = File.basename gem
+      next if scores.has_key? project unless $f and scores[project][0] < 0
+      dirty = true
+      begin
+        warn gem
+        dir = gem.sub(/\.gem$/, '')
+        Dir.mkdir dir
+        Dir.chdir dir do
+          system "(tar -Oxf ../#{gem} data.tar.gz | tar zxf -) 2> /dev/null"
+          system "chmod -R a+r ."
+          scores[project] = score_for(File.directory?('lib') ? 'lib' : '.')
+        end
+      ensure
+        system "rm -rf #{dir}"
+      end
+
+      if i % 500 == 0 then
+        save_scores scores
+      end
+    end
+  end
+ensure
+  save_scores scores if dirty
+end
+
+scores.reject! { |k,v| v.first.nil? or Fixnum === v.last or v.last.last < 0 }
+
+class Array
+  def sum
+    sum = 0
+    self.each { |i| sum += i }
+    sum
+  end
+
+  def average
+    return self.sum / self.length.to_f
+  end
+
+  def sample_variance
+    avg = self.average
+    sum = 0
+    self.each { |i| sum += (i - avg) ** 2 }
+    return (1 / self.length.to_f * sum)
+  end
+
+  def stddev
+    return Math.sqrt(self.sample_variance)
+  end
+end
+
+def title heading
+  puts
+  puts "#{heading}:"
+  puts
+  yield if block_given?
+end
+
+def report title, data
+  max = data.map { |d| d.first.size }.max
+
+  title "Top #{data.size} #{title}" if title
+  data.each_with_index do |(n, c, a, s), i|
+    puts "%4d: %-#{max}s: %4d methods, %8.2f +/- %8.2f flog" % [i + 1, n, c, a, s]
+  end
+end
+
+project_numbers = scores.map { |k,v| [k, v[1..-1].map {|_,n| n}.flatten] }
+project_stats   = project_numbers.map { |k,v| [k, v.size, v.average, v.stddev] }
+
+title "Statistics" do
+  flog_numbers = scores.map { |k,v| v.first }
+  all_scores = scores.map { |k,v| v[1..-1].map { |_,n| n } }.flatten
+  method_counts = project_stats.map { |n,c,a,s| c }
+
+  puts "total # gems      : %8d" % scores.size
+  puts "total # methods   : %8d" % all_scores.size
+  puts "avg methods / gem : %8.2f +/- %8.2f" % [method_counts.average, method_counts.stddev]
+  puts "avg flog / project: %8.2f +/- %8.2f" % [flog_numbers.average, flog_numbers.stddev]
+  puts "avg flog / method : %8.2f +/- %8.2f" % [all_scores.average, all_scores.stddev]
+end
+
+def report_worst section, data
+  title section do
+    max_size = data.map { |k| k.first.size }.max
+    data.each_with_index do |(k,v), i|
+      puts "%3d: %9.2f: %-#{max_size}s %s" % [i + 1, *yield(k, v)]
+    end
+  end
+end
+
+worst = scores.sort_by { |k,v| -v.first }.first(max)
+report_worst "Worst Projects EVAR", worst do |project, score|
+  [score.first, project, $owners[project].join(', ')]
+end
+
+worst = scores.sort_by { |k,v| -v.last.last }.first(max)
+report_worst "Worst Methods EVAR", worst do |project, methods|
+  [methods.last.last, project, methods.last.first]
+end
+
+report "Methods per Gem", project_stats.sort_by { |n, c, a, sd| -c }.first(max)
+report "Avg Flog / Method", project_stats.sort_by { |n, c, a, sd| -a }.first(max)
+
+$score_per_owner = Hash.new(0.0)
+$projects_per_owner = Hash.new { |h,k| h[k] = {} }
+$owners.each do |project, owners|
+  next unless scores.has_key? project # bad project
+  owners.each do |owner|
+    score = scores[project].first || 10000
+    $projects_per_owner[owner][project] = score
+    $score_per_owner[owner] += score
+  end
+end
+
+def report_bad_people section
+  title section
+  bad_people = yield
+  max_size = bad_people.map { |a| a.first.size }.max
+  fmt = "%4d: %#{max_size}s: %2d projects %8.1f tot %8.1f avg"
+  bad_people.each_with_index do |(name, projects), i|
+    avg = projects.values.average
+    puts fmt % [i + 1, name, projects.size, $score_per_owner[name], avg]
+  end
+end
+
+report_bad_people "Top Flog Scores per Developer" do
+  $projects_per_owner.sort_by { |k,v| -$score_per_owner[k] }.first(max)
+end
+
+report_bad_people "Most Prolific Developers" do |k,v|
+  $projects_per_owner.sort_by { |k,v| -v.size }.first(max)
+end

metadata

@@ -3,13 +3,13 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: flog
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
-date: 2007-08-01 00:00:00 -07:00
+  version: 1.1.0
+date: 2007-08-21 00:00:00 -07:00
 summary: Flog reports the most tortured code in an easy to read pain report. The higher the score, the more pain the code is in.
 require_paths: 
 - lib
 email: ryand-ruby@zenspider.com
-homepage: http://rubyforge.org/projects/seattlerb
+homepage: http://ruby.sadi.st/
 rubyforge_project: seattlerb
 description: "Flog reports the most tortured code in an easy to read pain report. The higher the score, the more pain the code is in.  % ./bin/flog bin/flog Total score = 128.7  Flog#report: (21) 4: puts 2: sort_by ..."
 autorequire: 
@@ -35,6 +35,8 @@ files:
 - Rakefile
 - bin/flog
 - lib/flog.rb
+- unpack.rb
+- update_scores.rb
 test_files: []
 
 rdoc_options: 
@@ -67,5 +69,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.2.2
+        version: 1.3.0
     version: