ParseTree 1.1.0

data/parse_tree_abc

@@ -0,0 +1,62 @@
+#!/usr/local/bin/ruby -w
+
+# ABC metric
+#
+# Assignments, Branches, and Calls
+#
+# A simple way to measure the complexity of a function or method.
+
+require 'parse_tree'
+
+old_classes = []
+ObjectSpace.each_object(Module) do |klass|
+  old_classes << klass
+end
+
+ARGV.each do |name|
+  require name
+end
+
+new_classes = []
+ObjectSpace.each_object(Module) do |klass|
+  new_classes << klass
+end
+
+score = {}
+
+new_classes -= old_classes
+
+new_classes.each do |klass|
+  ParseTree.new.parse_tree(klass).each do |defn|
+    a=b=c=0
+    defn.shift
+    name = defn.shift
+    tokens = defn.flatten.find_all { |t| Symbol === t }
+    tokens.each do |token|
+      case token
+      when :attrasgn, :attrset, :dasgn_curr, :iasgn, :lasgn, :masgn then
+        a += 1
+      when :and, :case, :else, :if, :iter, :or, :rescue, :until, :when, :while  then
+        b += 1
+      when :call, :fcall, :super, :vcall, :yield then
+        c += 1
+      when :args, :argscat, :array, :begin, :block, :bool, :cfunc, :colon2, :const, :cvar, :defined, :defn, :dregx, :dstr, :dvar, :dxstr, :ensure, :false, :fbody, :gvar, :hash, :ivar, :lit, :long, :lvar, :match2, :match3, :nil, :not, :nth_ref, :return, :scope, :self, :splat, :str, :to_ary, :true, :unknown, :value, :void, :zarray, :zarray, :zclass, :zsuper then
+        # ignore
+      else
+        puts "unhandled token #{token.inspect}"
+      end
+    end
+    key = ["#{klass}.#{name}", a, b, c]
+    val = a+b+c
+    score[key] = val
+  end
+end
+
+puts "Method = assignments + branches + calls = total"
+puts
+count = 1
+score.sort_by { |k,v| v }.reverse.each do |key,val|
+  name, a, b, c = *key
+  printf "%3d) %-50s = %2d + %2d + %2d = %3d\n", count, name, a, b, c, val
+  count += 1
+end

data/parse_tree_show

@@ -0,0 +1,28 @@
+#!/usr/local/bin/ruby -w
+
+require 'pp'
+require 'parse_tree'
+
+old_classes = []
+ObjectSpace.each_object(Module) do |klass|
+  old_classes << klass
+end
+
+ARGV.each do |name|
+  if name == "-" then
+    eval $stdin.read
+  else
+    require name
+  end
+end
+
+new_classes = []
+ObjectSpace.each_object(Module) do |klass|
+  new_classes << klass
+end
+
+new_classes -= old_classes
+
+new_classes.each do |klass|
+  pp ParseTree.new.parse_tree(klass)
+end

data/sexp_processor.rb

@@ -0,0 +1,301 @@
+
+$TESTING = false unless defined? $TESTING
+
+class Object
+  def deep_clone
+    Marshal.load(Marshal.dump(self))
+  end
+end
+
+class Sexp < Array # ZenTest FULL
+
+  @@array_types = [ :array, :args, ]
+
+  attr_accessor :accessors
+  attr_accessor :unpack
+
+  alias_method :unpack?, :unpack
+
+  def initialize(*args)
+    @unpack = false
+    @accessors = []
+    super(args)
+  end
+
+  def array_type?
+    type = self.first
+    @@array_types.include? type
+  end
+
+  def each_of_type(t, &b)
+    each do | elem |
+      if Sexp === elem then
+        elem.each_of_type(t, &b)
+        b.call(elem) if elem.first == t
+      end
+    end
+  end
+
+  # TODO: need to write test
+  def find_and_replace_all(from, to)
+    each_with_index do | elem, index |
+      if Sexp === elem then
+        elem.find_and_replace_all(from, to)
+      else
+        self[index] = to if elem == from
+      end
+    end
+  end
+
+  def method_missing(meth, *a, &b)
+    super unless @accessors.include? meth
+
+    index = @accessors.index(meth) + 1 # skip type
+    return self.at(index)
+  end
+
+  def sexp_body
+    self[1..-1]
+  end
+
+  def ==(obj)
+    case obj
+    when Sexp
+      super
+    else
+      false
+    end
+  end
+
+  def to_a
+    self.map { |o| Sexp === o ? o.to_a : o }
+  end
+
+  def inspect
+    sexp_str = self.map {|x|x.inspect}.join(', ')
+    return "Sexp.new(#{sexp_str})"
+  end
+
+  def pretty_print(q)
+    q.group(1, 's(', ')') do
+      q.seplist(self) {|v| q.pp v }
+    end
+  end
+
+  def to_s
+    inspect
+  end
+
+  def shift
+    raise "I'm empty" if self.empty?
+    super
+  end if $DEBUG and $TESTING
+
+end
+
+def s(*args) # stupid shortcut to make indentation much cleaner
+  Sexp.new(*args)
+end
+
+##
+# SexpProcessor provides a uniform interface to process Sexps.
+#
+# In order to create your own SexpProcessor subclass you'll need
+# to call super in the initialize method, then set any of the
+# Sexp flags you want to be different from the defaults.
+#
+# SexpProcessor uses a Sexp's type to determine which process
+# method to call in the subclass.  For Sexp <code>s(:lit,
+# 1)</code> SexpProcessor will call #process_lit.
+#
+# You can also provide a default method to call for any Sexp
+# types without a process_ method.
+#
+# Here is a simple example:
+#
+#   class MyProcessor < SexpProcessor
+#   
+#     def initialize
+#       super
+#       self.strict = false
+#     end
+#   
+#     def process_lit(exp)
+#       val = exp.shift
+#       return val
+#     end
+#   
+#   end
+
+class SexpProcessor
+  
+  ##
+  # A default method to call if a process_ method is not found
+  # for the Sexp type.
+
+  attr_accessor :default_method
+
+  ##
+  # Emit a warning when the method in #default_method is called.
+
+  attr_accessor :warn_on_default
+
+  ##
+  # Automatically shifts off the Sexp type before handing the
+  # Sexp to process_
+
+  attr_accessor :auto_shift_type
+
+  ##
+  # A list of Sexp types.  Raises an exception if a Sexp type in
+  # this list is encountered.
+
+  attr_accessor :exclude
+
+  ##
+  # Raise an exception if no process_ method is found for a Sexp.
+
+  attr_accessor :strict
+
+  ##
+  # A Hash of Sexp types and Regexp.
+  #
+  # Print a debug message if the Sexp type matches the Hash key
+  # and the Sexp's #inspect output matches the Regexp.
+
+  attr_accessor :debug
+
+  ##
+  # Expected result class
+
+  attr_accessor :expected
+
+  ##
+  # Raise an exception if the Sexp is not empty after processing
+
+  attr_accessor :require_empty
+
+  ##
+  # Adds accessor methods to the Sexp
+
+  attr_accessor :sexp_accessors
+
+  ##
+  # Creates a new SexpProcessor.  Use super to invoke this
+  # initializer from SexpProcessor subclasses, then use the
+  # attributes above to customize the functionality of the
+  # SexpProcessor
+
+  def initialize
+    @collection = []
+    @default_method = nil
+    @warn_on_default = true
+    @auto_shift_type = false
+    @strict = false
+    @exclude = []
+    @debug = {}
+    @expected = Sexp
+    @require_empty = true
+    @sexp_accessors = {}
+
+    # we do this on an instance basis so we can subclass it for
+    # different processors.
+    @methods = {}
+
+    public_methods.each do |name|
+      next unless name =~ /^process_(.*)/
+      @methods[$1.intern] = name.intern
+    end
+  end
+
+  ##
+  # Default Sexp processor.  Invokes process_ methods matching
+  # the Sexp type given.  Performs additional checks as specified
+  # by the initializer.
+
+  def process(exp)
+    return nil if exp.nil?
+
+    exp_orig = exp.deep_clone if $DEBUG
+    result = self.expected.new
+
+    type = exp.first
+
+    if @debug.include? type then
+      str = exp.inspect
+      puts "// DEBUG: #{str}" if str =~ @debug[type]
+    end
+
+    if Sexp === exp then
+      if @sexp_accessors.include? type then
+        exp.accessors = @sexp_accessors[type]
+      else
+        exp.accessors = [] # clean out accessor list in case it changed
+      end
+    end
+    
+    raise SyntaxError, "'#{type}' is not a supported node type." if @exclude.include? type
+
+    meth = @methods[type] || @default_method
+    if meth then
+      if @warn_on_default and meth == @default_method then
+        $stderr.puts "WARNING: falling back to default method #{meth} for #{exp.first}"
+      end
+      if @auto_shift_type and meth != @default_method then
+        exp.shift
+      end
+      result = self.send(meth, exp)
+      raise TypeError, "Result must be a #{@expected}, was #{result.class}:#{result.inspect}" unless @expected === result
+      if $DEBUG then
+        raise "exp not empty after #{self.class}.#{meth} on #{exp.inspect} from #{exp_orig.inspect}" if @require_empty and not exp.empty?
+      else
+        raise "exp not empty after #{self.class}.#{meth} on #{exp.inspect}" if @require_empty and not exp.empty?
+      end
+    else
+      unless @strict then
+        until exp.empty? do
+          sub_exp = exp.shift
+          sub_result = nil
+          if Array === sub_exp then
+            sub_result = process(sub_exp)
+            raise "Result is a bad type" unless Array === sub_exp
+            raise "Result does not have a type in front: #{sub_exp.inspect}" unless Symbol === sub_exp.first unless sub_exp.empty?
+          else
+            sub_result = sub_exp
+          end
+          if Sexp === sub_result && sub_result.unpack? then
+            result.push(*sub_result)
+          else
+            result << sub_result
+          end
+        end
+
+        # NOTE: this is costly, but we are in the generic processor
+        # so we shouldn't hit it too much with RubyToC stuff at least.
+        #if Sexp === exp and not exp.sexp_type.nil? then
+        begin
+          result.sexp_type = exp.sexp_type
+        rescue Exception
+          # nothing to do, on purpose
+        end
+      else
+        raise SyntaxError, "Bug! Unknown type #{type.inspect} to #{self.class}"
+      end
+    end
+    result
+  end
+
+  def generate # :nodoc:
+    raise "not implemented yet"
+  end
+
+  ##
+  # Raises unless the Sexp type for +list+ matches +typ+
+
+  def assert_type(list, typ)
+    raise TypeError, "Expected type #{typ.inspect} in #{list.inspect}" \
+      if list.first != typ
+  end
+
+end
+

data/something.rb

@@ -0,0 +1,162 @@
+
+class Something
+
+  # basically: do we work at all?
+  def empty
+  end
+
+  # First order transformation: basic language constructs
+  def stupid
+    return nil
+  end
+
+  def simple(arg1)
+    print arg1
+    puts((4 + 2).to_s)
+  end
+
+  def global
+    $stderr.fputs("blah")
+  end
+
+  def lasgn_call
+    c = 2 + 3
+  end
+
+  def conditional1(arg1)
+    if arg1 == 0 then
+      return 1
+    end
+  end
+
+  def conditional2(arg1)
+    unless arg1 == 0 then
+      return 2
+    end
+  end
+
+  def conditional3(arg1)
+    if arg1 == 0 then
+      return 3
+    else
+      return 4
+    end
+  end
+
+  def conditional4(arg1)
+    if arg1 == 0 then
+      return 2
+    elsif arg1 < 0 then
+      return 3
+    else
+      return 4
+    end
+  end
+
+  def iteration1
+    array = [1, 2, 3]
+    array.each do |x|
+      puts(x.to_s)
+    end
+  end
+
+  def iteration2
+    array = [1, 2, 3]
+    array.each { |x| puts(x.to_s) }
+  end
+
+  def iteration3
+    array1 = [1, 2, 3]
+    array2 = [4, 5, 6, 7]
+    array1.each do |x|
+      array2.each do |y|
+	puts(x.to_s)
+	puts(y.to_s)
+      end
+    end
+  end
+
+  def iteration4
+    1.upto(3) do |n|
+      puts n.to_s
+    end
+  end
+
+  def iteration5
+    3.downto(1) do |n|
+      puts n.to_s
+    end
+  end
+
+  def iteration6
+    3.downto(1) do
+      puts "hello"
+    end
+  end
+
+  def case_stmt
+    var = 2
+    result = ""
+    case var
+    when 1 then
+      # block
+      puts "something"
+      result = "red"
+    when 2, 3 then
+      result = "yellow"
+    when 4 then
+      # nothing
+    else
+      result = "green"
+    end
+
+    case result
+    when "red" then
+      var = 1
+    when "yellow" then
+      var = 2
+    when "green" then
+      var = 3
+    end
+
+    return result
+  end
+
+  # Other edge cases:
+
+  def multi_args(arg1, arg2)
+    arg3 = arg1 * arg2 * 7
+    puts(arg3.to_s)
+    return "foo"
+  end
+
+  def bools(arg1)
+    unless arg1.nil? then
+      return true
+    else
+      return false
+    end
+  end
+
+  def eric_is_stubborn
+    var = 42
+    var2 = var.to_s
+    $stderr.fputs(var2)
+    return var2
+  end
+
+  def interpolated
+    var = 14
+    var2 = "var is #{var}. So there."
+  end
+
+  def unknown_args(arg1, arg2)
+    # does nothing
+    return arg1
+  end
+
+  def determine_args
+    5 == unknown_args(4, "known")
+  end
+
+end