self-flagellation 1.0.0

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 / 2008-05-30
+
+* 1 major enhancement
+  * Birthday!

data/Manifest.txt

@@ -0,0 +1,19 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/flagellate
+lib/self-flagellation.rb
+lib/self-flagellation/flagellate.rb
+tasks/ann.rake
+tasks/bones.rake
+tasks/gem.rake
+tasks/manifest.rake
+tasks/notes.rake
+tasks/post_load.rake
+tasks/rdoc.rake
+tasks/rubyforge.rake
+tasks/setup.rb
+tasks/spec.rake
+tasks/svn.rake
+tasks/test.rake

data/README.txt

@@ -0,0 +1,53 @@
+self-flagellation
+    by Ben Scofield
+    http://github.com/bscofield/self-flagellation
+original flog code
+    by Ryan Davis, Seattle.rb
+    http://ruby.sadi.st/
+    http://rubyforge.org/projects/seattlerb
+
+== DESCRIPTION:
+
+Self-flagellation is an addition/extension of Ryan Davis's flog, which 
+allows you to specify a customized set of complexity metrics (instead 
+of just using the defaults built into the gem)
+
+== FEATURES/PROBLEMS:
+
+All the features of flog are here, with the addition of a -f option 
+available on the commandline. 
+
+== SYNOPSIS:
+
+> ./bin/flagellate -f=data/scores.yml bin/flagellate
+Total Score: xxx
+
+== INSTALL:
+
+sudo gem install self-flagellation
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Ben Scofield
+(original flog code Copyright (c) 2007 Ryan Davis)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+load 'tasks/setup.rb'
+
+ensure_in_path 'lib'
+require 'self-flagellation'
+
+PROJ.version = SelfFlagellation::VERSION
+PROJ.name = 'self-flagellation'
+PROJ.authors = 'Ben Scofield'
+PROJ.email = 'bscofield@gmail.com'
+PROJ.url = 'http://github.com/bscofield/self-flagellation'
+PROJ.rubyforge.name = 'viget'
+
+PROJ.spec.opts << '--color'
+
+# EOF

data/bin/flagellate

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), '..', 'lib', 'self-flagellation'))
+
+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 "  -f=path use complexity scores from YAML file in PATH"
+  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 = SelfFlagellation::Flagellate.new
+
+if defined? $f and String === $f then
+  flogger.reset_scores $f
+end
+
+flogger.flog_files ARGV
+flogger.report

data/lib/self-flagellation.rb

@@ -0,0 +1,56 @@
+# $Id$
+
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? SelfFlagellation
+
+module SelfFlagellation
+
+  # :stopdoc:
+  VERSION = '1.0.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, *args)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, *args)
+  end
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module SelfFlagellation
+
+SelfFlagellation.require_all_libs_relative_to __FILE__
+
+end  # unless defined?
+
+# EOF

data/lib/self-flagellation/flagellate.rb

@@ -0,0 +1,491 @@
+require 'yaml'
+require 'rubygems'
+require 'parse_tree'
+require 'sexp_processor'
+require 'unified_ruby'
+
+$a ||= false
+$s ||= false
+$v ||= false
+
+module SelfFlagellation
+  class Flagellate < SexpProcessor
+    include UnifiedRuby
+
+    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,
+    :extend => 2,
+    :include => 2,
+    :instance_method => 2,
+    :instance_methods => 2,
+    :method_added => 2,
+    :method_defined? => 2,
+    :method_removed => 2,
+    :method_undefined => 2,
+    :private_class_method => 2,
+    :private_instance_methods => 2,
+    :private_method_defined? => 2,
+    :protected_instance_methods => 2,
+    :protected_method_defined? => 2,
+    :public_class_method => 2,
+    :public_instance_methods => 2,
+    :public_method_defined? => 2,
+    :remove_method => 2,
+    :send => 3,
+    :undef_method => 2)
+
+    # 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)
+      @klasses = []
+      @methods = []
+      self.auto_shift_type = true
+      self.require_empty = false # HACK
+      self.reset
+    end
+
+    def reset_scores(path = nil)
+      if path
+        yaml = YAML.load_file(path)
+        @other_scores = yaml['OTHER_SCORES']
+        @scores = Hash.new(1)
+        @scores.merge!(yaml['SCORES'])
+      end
+    rescue
+      nil
+    end
+
+    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 bleed exp
+      process exp.shift until exp.empty?
+    end
+
+    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
+            end
+          end
+        end
+      end
+    end
+
+    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
+
+      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]
+        io.puts "%s: (%.1f)" % [klass_method, total]
+        calls.sort_by { |k,v| -v }.each do |call, count|
+          io.puts "  %6.1f: %s" % [count, call]
+        end
+
+        current += total
+        break if current >= max
+      end
+    ensure
+      self.reset
+    end
+
+    def reset
+      @totals = @total_score = nil
+      @multiplier = 1.0
+      @calls = Hash.new { |h,k| h[k] = Hash.new 0 }
+    end
+
+    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
+
+    def other_scores
+      @other_scores || OTHER_SCORES
+    end
+
+    def scores
+      @scores || SCORES
+    end
+
+    ############################################################
+    # Process Methods:
+
+    def process_alias(exp)
+      process exp.shift
+      process exp.shift
+      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
+
+    # [:block_pass, [:lit, :blah], [:fcall, :foo]]
+    def process_block_pass(exp)
+      arg = exp.shift
+      call = exp.shift
+
+      add_to_score :block_pass, other_scores[:block]
+
+      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!]
+      else
+        raise({:block_pass => [arg, call]}.inspect)
+      end
+
+      process arg
+      process call
+
+      s()
+    end
+
+    def process_call(exp)
+      bad_dog! 0.2 do
+        recv = process exp.shift
+      end
+      name = exp.shift
+      bad_dog! 0.2 do
+        args = process exp.shift
+      end
+
+      score = scores[name]
+      add_to_score name, score
+
+      s()
+    end
+
+    def process_case(exp)
+      add_to_score :branch, other_scores[:branch]
+      process exp.shift # recv
+      bad_dog! 0.1 do
+        bleed exp
+      end
+      s()
+    end
+
+    def process_class(exp)
+      self.klass exp.shift do
+        bad_dog! 1.0 do
+          supr = process exp.shift
+        end
+        bleed exp
+      end
+      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)
+      self.method exp.shift do
+        bleed exp
+      end
+      s()
+    end
+
+    def process_defs(exp)
+      process exp.shift
+      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
+
+    def process_lit(exp)
+      value = exp.shift
+      case value
+      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]
+      when Float, Symbol, Regexp, Range then
+        # do nothing
+      else
+        raise value.inspect
+      end
+      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)
+      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
+      s()
+    end
+
+    def process_sclass(exp)
+      bad_dog! 0.5 do
+        recv = process exp.shift
+        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
+
+    def process_yield(exp)
+      add_to_score :yield, other_scores[:yield]
+      bleed exp
+      s()
+    end
+  end
+end