ParseTree 1.3.0 → 1.3.2

data/History.txt

@@ -1,3 +1,19 @@
+*** 1.3.2 / 2005-01-04
+
++ 1 minor enhancement
+	+ Added total line to end of ABC metric report.
++ 1 bug fix
+	+ Updates for ruby 1.8.2 parse tree changes.
+
+*** 1.3.1 / 2004-12-09
+
++ 1 minor enhancement
+	+ Added rewrite_<type> processing.
++ 2 bug fixes
+	+ Renamed SexpProcessor's #exclude to #unsupported.
+	+ Fixed a bus error when an attrasgn uses self.
+	+ Added support for cfunc now that we found a repro.
+
 *** 1.3.0 / 2004-12-06
 
 + 3 minor enhancements

data/Makefile

@@ -1,10 +1,10 @@
 RUBY?=ruby
-RUBY_FLAGS?=-w -Ilib
+RUBY_FLAGS?=-w -Ilib -Ibin
 RUBY_LIB?=$(shell $(RUBY) -rrbconfig -e 'include Config; print CONFIG["sitelibdir"]')
 PREFIX?=/usr/local
 
 all test: FORCE
-	$(RUBY) $(RUBY_FLAGS) test/test_all.rb
+	GEM_SKIP=ParseTree $(RUBY) $(RUBY_FLAGS) test/test_all.rb
 
 # we only install test_sexp_processor.rb to help make ruby_to_c's
 # subclass tests work.

data/bin/parse_tree_abc

@@ -13,6 +13,8 @@ rescue LoadError
   require 'parse_tree'
 end
 
+  require 'sexp_processor'
+
 old_classes = []
 ObjectSpace.each_object(Module) do |klass|
   old_classes << klass
@@ -31,20 +33,7 @@ score = {}
 
 new_classes -= old_classes
 
-def sexp_types(exp)
-  result = []
-  if Array === exp.first then
-    result = sexp_types(exp.first)
-  else
-    result << exp.shift
-    exp.grep(Array).each do |subexp|
-      result.concat(sexp_types(subexp))
-    end
-  end
-  result
-end
-
-klasses = ParseTree.new.parse_tree(*new_classes)
+klasses = Sexp.from_array(ParseTree.new.parse_tree(*new_classes))
 klasses.each do |klass|
   klass.shift # :class
   klassname = klass.shift
@@ -55,7 +44,7 @@ klasses.each do |klass|
     a=b=c=0
     defn.shift
     methodname = defn.shift
-    tokens = sexp_types(defn)
+    tokens = defn.structure.flatten
     tokens.each do |token|
       case token
       when :attrasgn, :attrset, :dasgn_curr, :iasgn, :lasgn, :masgn then
@@ -79,8 +68,14 @@ end
 puts "Method = assignments + branches + calls = total"
 puts
 count = 1
+ta = tb = tc = tval = 0
 score.sort_by { |k,v| v }.reverse.each do |key,val|
   name, a, b, c = *key
+  ta += a
+  tb += b
+  tc += c
+  tval += val
   printf "%3d) %-50s = %2d + %2d + %2d = %3d\n", count, name, a, b, c, val
   count += 1
 end
+printf "%3d) %-50s = %2d + %2d + %2d = %3d\n", count, "Total", ta, tb, tc, tval

data/lib/parse_tree.rb

@@ -27,7 +27,7 @@ end
 
 class ParseTree
 
-  VERSION = '1.3.0'
+  VERSION = '1.3.2'
 
   ##
   # Initializes a ParseTree instance. Includes newline nodes if
@@ -647,7 +647,11 @@ again_no_block:
 
   case NODE_ATTRASGN:           // literal.meth = y u1 u2 u3
     // node id node
-    add_to_parse_tree(current, node->nd_1st, newlines, locals);
+    if (node->nd_1st == RNODE(1)) {
+      add_to_parse_tree(current, NEW_SELF(), newlines, locals);
+    } else {
+      add_to_parse_tree(current, node->nd_1st, newlines, locals);
+    }
     rb_ary_push(current, ID2SYM(node->u2.id));
     add_to_parse_tree(current, node->nd_3rd, newlines, locals);
     break;
@@ -664,10 +668,14 @@ again_no_block:
     // Nothing to do here... we are in an iter block
     break;
 
+  case NODE_CFUNC:
+    rb_ary_push(current, INT2FIX(node->nd_cfnc));
+    rb_ary_push(current, INT2FIX(node->nd_argc));
+    break;
+
   // Nodes we found but have yet to decypher
   // I think these are all runtime only... not positive but...
   case NODE_MEMO:               // enum.c zip
-  case NODE_CFUNC:
   case NODE_CREF:
   case NODE_IFUNC:
   // #defines:

data/lib/sexp_processor.rb

@@ -36,6 +36,25 @@ class Sexp < Array # ZenTest FULL
     super(args)
   end
 
+  def self.from_array(a)
+    ary = Array === a ? a : [a]
+
+    result = self.new
+
+    ary.each do |x|
+      case x
+      when Sexp
+        result << x
+      when Array
+        result << self.from_array(x)
+      else
+        result << x
+      end
+    end
+
+    result
+  end
+
   ##
   # Returns true if the node_type is +array+ or +args+.
   #
@@ -110,6 +129,23 @@ class Sexp < Array # ZenTest FULL
     self[1..-1]
   end
 
+  ##
+  # Returnes the bare bones structure of the sexp.
+  # s(:a, :b, s(:c, :d), :e) => s(:a, s(:c))
+
+  def structure
+    result = self.class.new
+    if Array === self.first then
+      result = self.first.structure
+    else
+      result << self.shift
+      self.grep(Array).each do |subexp|
+        result << subexp.structure
+      end
+    end
+    result
+  end
+
   def ==(obj) # :nodoc:
     case obj
     when Sexp
@@ -125,7 +161,7 @@ class Sexp < Array # ZenTest FULL
 
   def inspect # :nodoc:
     sexp_str = self.map {|x|x.inspect}.join(', ')
-    return "Sexp.new(#{sexp_str})"
+    return "s(#{sexp_str})"
   end
 
   def pretty_print(q) # :nodoc:
@@ -145,7 +181,7 @@ class Sexp < Array # ZenTest FULL
   def shift
     raise "I'm empty" if self.empty?
     super
-  end if $DEBUG and $TESTING
+  end if $DEBUG or $TESTING
 
 end
 
@@ -156,6 +192,18 @@ def s(*args)
   Sexp.new(*args)
 end
 
+##
+# Raised by SexpProcessor if it sees a node type listed in its
+# unsupported list.
+
+class UnsupportedNodeError < SyntaxError; end
+
+##
+# Raised by SexpProcessor if a processor did not process every node in
+# a sexp and @require_empty is true.
+
+class NotEmptyError < SyntaxError; end
+
 ##
 # SexpProcessor provides a uniform interface to process Sexps.
 #
@@ -163,12 +211,13 @@ end
 # 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.
+# 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, if it is defined.
 #
-# You can also provide a default method to call for any Sexp
-# types without a process_ method.
+# You can also specify a default method to call for any Sexp types
+# without a process_<type> method or use the default processor provided to
+# skip over them.
 #
 # Here is a simple example:
 #
@@ -187,7 +236,7 @@ end
 class SexpProcessor
   
   ##
-  # A default method to call if a process_ method is not found
+  # A default method to call if a process_<type> method is not found
   # for the Sexp type.
 
   attr_accessor :default_method
@@ -199,18 +248,19 @@ class SexpProcessor
 
   ##
   # Automatically shifts off the Sexp type before handing the
-  # Sexp to process_
+  # Sexp to process_<type>
 
   attr_accessor :auto_shift_type
 
   ##
-  # A list of Sexp types.  Raises an exception if a Sexp type in
-  # this list is encountered.
+  # An array that specifies node types that are unsupported by this
+  # processor. SexpProcesor will raise UnsupportedNodeError if you try
+  # to process one of those node types.
 
-  attr_accessor :exclude
+  attr_accessor :unsupported
 
   ##
-  # Raise an exception if no process_ method is found for a Sexp.
+  # Raise an exception if no process_<type> method is found for a Sexp.
 
   attr_accessor :strict
 
@@ -249,7 +299,7 @@ class SexpProcessor
     @warn_on_default = true
     @auto_shift_type = false
     @strict = false
-    @exclude = []
+    @unsupported = []
     @debug = {}
     @expected = Sexp
     @require_empty = true
@@ -257,18 +307,23 @@ class SexpProcessor
 
     # we do this on an instance basis so we can subclass it for
     # different processors.
-    @methods = {}
+    @processors = {}
+    @rewriters  = {}
 
     public_methods.each do |name|
-      next unless name =~ /^process_(.*)/
-      @methods[$1.intern] = name.intern
+      case name
+      when /^process_(.*)/ then
+        @processors[$1.intern] = name.intern
+      when /^rewrite_(.*)/ then
+        @rewriters[$1.intern]  = name.intern
+      end
     end
   end
 
   ##
-  # Default Sexp processor.  Invokes process_ methods matching
-  # the Sexp type given.  Performs additional checks as specified
-  # by the initializer.
+  # Default Sexp processor.  Invokes process_<type> methods matching
+  # the Sexp type given.  Performs additional checks as specified by
+  # the initializer.
 
   def process(exp)
     return nil if exp.nil?
@@ -291,22 +346,42 @@ class SexpProcessor
       end
     end
     
-    raise SyntaxError, "'#{type}' is not a supported node type." if @exclude.include? type
+    raise UnsupportedNodeError, "'#{type}' is not a supported node type." if @unsupported.include? type
 
-    meth = @methods[type] || @default_method
+    # do a pass through the rewriter first, if any, reassign back to exp
+    meth = @rewriters[type]
     if meth then
-      if @warn_on_default and meth == @default_method then
-        $stderr.puts "WARNING: falling back to default method #{meth} for #{exp.first}"
+      new_exp = self.send(meth, exp)
+      # REFACTOR: duplicated from below
+      if @require_empty and not exp.empty? then
+        msg = "exp not empty after #{self.class}.#{meth} on #{exp.inspect}"
+        if $DEBUG then
+          msg += " from #{exp_orig.inspect}" 
+        end
+        raise NotEmptyError, msg
       end
-      if @auto_shift_type and meth != @default_method then
-        exp.shift
+      exp = new_exp
+    end
+
+    # now do a pass with the real processor (or generic
+    meth = @processors[type] || @default_method
+    if meth then
+
+      if @warn_on_default and meth == @default_method then
+        $stderr.puts "WARNING: Using default method #{meth} for #{type}"
       end
+
+      exp.shift if @auto_shift_type and meth != @default_method
+
       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?
+
+      if @require_empty and not exp.empty? then
+        msg = "exp not empty after #{self.class}.#{meth} on #{exp.inspect}"
+        if $DEBUG then
+          msg += " from #{exp_orig.inspect}" 
+        end
+        raise NotEmptyError, msg
       end
     else
       unless @strict then

data/test/something.rb

@@ -159,6 +159,11 @@ class Something
     5 == unknown_args(4, "known")
   end
 
+  def attrasgn
+    42.method = y
+    self.type = other.type
+  end
+
   def self.bmethod_maker
     define_method(:bmethod_added) do |x|
       x + 1

data/test/test_parse_tree.rb

@@ -11,7 +11,9 @@ class TestParseTree < Test::Unit::TestCase
   @@missing = [nil]
   @@empty = [:defn, :empty,
     [:scope,
-      [:args]]]
+      [:block,
+        [:args],
+        [:nil]]]]
   @@stupid = [:defn, :stupid,
     [:scope,
       [:block,
@@ -262,8 +264,19 @@ class TestParseTree < Test::Unit::TestCase
      [:dasgn_curr, :x],
      [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]]
 
+  @@attrasgn = [:defn,
+    :attrasgn,
+    [:scope,
+      [:block,
+        [:args],
+        [:attrasgn, [:lit, 42], :method=, [:array, [:vcall, :y]]],
+        [:attrasgn, 
+          [:self],
+          :type=, 
+          [:array, [:call, [:vcall, :other], :type]]]]]]
+  
   @@__all = [:class, :Something, :Object]
-
+  
   def setup
     @thing = ParseTree.new(false)
   end

data/test/test_sexp_processor.rb

@@ -36,7 +36,7 @@ class TestProcessor < SexpProcessor # ZenTest SKIP
   end
 
   def process_nonempty(exp)
-    exp
+    s(*exp)
   end
 
   def process_broken(exp)
@@ -54,6 +54,14 @@ class TestProcessor < SexpProcessor # ZenTest SKIP
     return exp.shift
   end 
 
+  def rewrite_rewritable(exp)
+    return s(exp.shift, exp.pop, exp.shift)
+  end
+
+  def process_rewritable(exp)
+    return s(exp.shift, exp.shift == 2, exp.shift == 1)
+  end
+
 end
 
 class TestProcessorDefault < SexpProcessor # ZenTest SKIP
@@ -72,19 +80,15 @@ end
 
 class TestSexp < Test::Unit::TestCase # ZenTest FULL
 
-  def util_sexp_class
-    Object.const_get(self.class.name[4..-1])
-  end
-
   def setup
-    @sexp_class = util_sexp_class
+    @sexp_class = Object.const_get(self.class.name[4..-1])
     @processor = SexpProcessor.new
     @sexp = @sexp_class.new(1, 2, 3)
   end
 
   def test_new_nested
-    @sexp = Sexp.new(:lasgn, "var", Sexp.new(:str, "foo"))
-    assert_equal('Sexp.new(:lasgn, "var", Sexp.new(:str, "foo"))',
+    @sexp = s(:lasgn, "var", s(:str, "foo"))
+    assert_equal('s(:lasgn, "var", s(:str, "foo"))',
                  @sexp.inspect)
   end
 
@@ -99,12 +103,12 @@ class TestSexp < Test::Unit::TestCase # ZenTest FULL
   end
 
   def test_equals_sexp
-    sexp2 = Sexp.new(1, 2, 3)
+    sexp2 = s(1, 2, 3)
     assert_equal(@sexp, sexp2)
   end
 
   def test_equals_not_body
-    sexp2 = Sexp.new(1, 2, 5)
+    sexp2 = s(1, 2, 5)
     assert_not_equal(@sexp, sexp2)
   end
  
@@ -159,20 +163,11 @@ class TestSexp < Test::Unit::TestCase # ZenTest FULL
     assert_equal(expected, @sexp)
   end
 
-  def test_inspect
-    k = @sexp_class
-    assert_equal("#{k}.new()",
-                 k.new().inspect)
-    assert_equal("#{k}.new(:a)",
-                 k.new(:a).inspect)
-    assert_equal("#{k}.new(:a, :b)",
-                 k.new(:a, :b).inspect)
-    assert_equal("#{k}.new(:a, #{k}.new(:b))",
-                 k.new(:a, k.new(:b)).inspect)
-  end
+  def test_structure
+    @sexp    = s(:a, 1, 2, s(:b, 3, 4), 5, 6)
+    expected = s(:a, s(:b))
 
-  def test_to_s
-    test_inspect
+    assert_equal(expected, @sexp.structure)
   end
 
   def test_method_missing
@@ -187,6 +182,23 @@ class TestSexp < Test::Unit::TestCase # ZenTest FULL
     end
   end
 
+  def test_inspect
+    k = @sexp_class
+    n = k.name[0].chr.downcase
+    assert_equal("#{n}()",
+                 k.new().inspect)
+    assert_equal("#{n}(:a)",
+                 k.new(:a).inspect)
+    assert_equal("#{n}(:a, :b)",
+                 k.new(:a, :b).inspect)
+    assert_equal("#{n}(:a, #{n}(:b))",
+                 k.new(:a, k.new(:b)).inspect)
+  end
+
+  def test_to_s
+    test_inspect
+  end
+
   def util_pretty_print(expect, input)
     io = StringIO.new
     PP.pp(input, io)
@@ -209,9 +221,11 @@ class TestSexp < Test::Unit::TestCase # ZenTest FULL
     assert_equal(1, @sexp.shift)
     assert_equal(2, @sexp.shift)
     assert_equal(3, @sexp.shift)
-    assert_nil(@sexp.shift)
-  end
 
+    assert_raise(RuntimeError) do
+      @sexp.shift
+    end
+  end
 end
 
 class TestSexpProcessor < Test::Unit::TestCase
@@ -273,15 +287,14 @@ class TestSexpProcessor < Test::Unit::TestCase
     end
   end
 
-  def test_exclude
-    @processor.exclude = [ :blah ]
-    assert_raise(SyntaxError) do
-      @processor.process([:blah, 1, 2, 3])
+  def test_unsupported_equal
+    @processor.strict = true
+    @processor.unsupported = [ :unsupported ]
+    assert_raises(UnsupportedNodeError) do
+      @processor.process([:unsupported, 42])
     end
   end
 
-  def test_exclude=; end # Handled
-
   def test_strict
     @processor.strict = true
     assert_raise(SyntaxError) do
@@ -300,7 +313,7 @@ class TestSexpProcessor < Test::Unit::TestCase
   end
 
   def test_require_empty_true
-    assert_raise(TypeError) do
+    assert_raise(NotEmptyError) do
       @processor.process([:nonempty, 1, 2, 3])
     end
   end
@@ -311,6 +324,17 @@ class TestSexpProcessor < Test::Unit::TestCase
     assert_equal([1, 2, 3], @processor.process(s(:strip, 1, 2, 3)))
   end
 
+  def test_process_rewrite
+    assert_equal(s(:rewritable, true, true),
+                 @processor.process(s(:rewritable, 1, 2)))
+  end
+
+  def test_process_rewrite_not_empty
+    assert_raise(NotEmptyError) do
+      @processor.process(s(:rewritable, 1, 2, 2))
+    end
+  end
+
   def test_assert_type_hit
     assert_nothing_raised do
       @processor.assert_type([:blah, 1, 2, 3], :blah)
@@ -353,7 +377,7 @@ class TestSexpProcessor < Test::Unit::TestCase
 
     @processor.expected = Hash
     assert_equal Hash, @processor.expected
-    assert !(Hash === Sexp.new()), "Hash === Sexp.new should not be true"
+    assert !(Hash === s()), "Hash === s() should not be true"
 
     assert_raises(TypeError) do
       @processor.process(s(:string, "string"))     # should raise
@@ -370,4 +394,3 @@ class TestSexpProcessor < Test::Unit::TestCase
   def test_warn_on_default=; end
 
 end
-

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.1
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
-date: 2004-12-07
+  version: 1.3.2
+date: 2005-01-04
 summary: Extract and enumerate ruby parse trees.
 require_paths: 
   - lib