ParseTree 1.6.0 → 1.6.1

data/History.txt

@@ -1,3 +1,12 @@
+*** 1.6.1 / 2006-11-11
+
++ 2 minor enhancements:
+	+ Have been going insane on the tests, expect more soon.
+	+ Cleaned up using named nodes, now do: args = exp.scope.block.args(:delete).
++ 2 bug fixes:
+	+ Fixed #parse_tree to return superclass in :const node.
+	+ Fixed while/until with no bodies (now nil).
+
 *** 1.6.0 / 2006-10-11
 
 + 2 major enhancements:
@@ -10,7 +19,7 @@
 	+ SexpProcessor's unsupported array now defaults to all the internal nodes.
 	+ Added Unique from ruby2c project.
 	+ something.rb got slimmed down to near nothing. About to be retired.
-+ 7 bug fixes:
++ 3 bug fixes:
 	+ Added changeset to Hoe spec.
 	+ Fixed up description to use paragraphs_of.
 	+ Fixed op_asgn1, alias, undef, dsym, match.

data/Rakefile

@@ -12,6 +12,7 @@ Hoe.new("ParseTree", ParseTree::VERSION) do |p|
   p.changes = p.paragraphs_of("History.txt", 1).join("\n\n")
   p.clean_globs << File.expand_path("~/.ruby_inline")
   p.extra_deps << ['RubyInline', '>= 3.2.0']
+  p.spec_extras[:require_paths] = proc { |paths| paths << 'test'; p paths }
 end
 
 desc 'Run against ruby 1.9 (from a multiruby install) with -d.'

data/lib/parse_tree.rb

@@ -25,7 +25,7 @@ require 'inline'
 
 class ParseTree
 
-  VERSION = '1.6.0'
+  VERSION = '1.6.1'
 
   ##
   # Front end translation method. 
@@ -82,7 +82,7 @@ class ParseTree
       code = if Class === klass then
                sc = klass.superclass
                sc_name = ((sc.nil? or sc.name.empty?) ? "nil" : sc.name).intern
-               [:class, klassname, sc_name]
+               [:class, klassname, [:const, sc_name]]
              else
                [:module, klassname]
              end
@@ -399,7 +399,11 @@ again_no_block:
   case NODE_WHILE:
   case NODE_UNTIL:
     add_to_parse_tree(current,  node->nd_cond, newlines, locals);
-    add_to_parse_tree(current,  node->nd_body, newlines, locals); 
+    if (node->nd_body) {
+      add_to_parse_tree(current,  node->nd_body, newlines, locals); 
+    } else {
+      rb_ary_push(current, Qnil);
+    }
     rb_ary_push(current, node->nd_3rd == 0 ? Qfalse : Qtrue);
     break;
 
@@ -865,10 +869,10 @@ static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE newlines, VALU
   NODE *node = NULL;
   ID id;
   VALUE result = rb_ary_new();
+  VALUE version = rb_const_get_at(rb_cObject,rb_intern("RUBY_VERSION"));
 
   (void) self; // quell warnings
 
-  VALUE version = rb_const_get_at(rb_cObject,rb_intern("RUBY_VERSION"));
   if (strcmp(StringValuePtr(version), #{RUBY_VERSION.inspect})) {
     rb_fatal("bad version, %s != #{RUBY_VERSION}\\n", StringValuePtr(version));
   }

data/lib/sexp.rb

@@ -10,16 +10,10 @@ class Sexp < Array # ZenTest FULL
 
   @@array_types = [ :array, :args, ]
 
-  ##
-  # Named positional parameters.
-  # Use with +SexpProcessor.require_empty=false+.
-  attr_accessor :accessors
-
   ##
   # Create a new Sexp containing +args+.
 
   def initialize(*args)
-    @accessors = []
     super(args)
   end
 
@@ -123,35 +117,19 @@ class Sexp < Array # ZenTest FULL
     return "s(#{sexp_str})"
   end
 
-  ##
-  # Fancy-Schmancy method used to implement named positional accessors
-  # via +accessors+.
-  #
-  # Example:
-  #
-  #   class MyProcessor < SexpProcessor
-  #     def initialize
-  #       super
-  #       self.require_empty = false
-  #       self.sexp_accessors = {
-  #         :call => [:lhs, :name, :rhs]
-  #       }
-  #       ...
-  #     end
-  #   
-  #     def process_call(exp)
-  #       lhs = exp.lhs
-  #       name = exp.name
-  #       rhs = exp.rhs
-  #       ...
-  #     end
-  #   end
-
-  def method_missing(meth, *a, &b)
-    super unless @accessors.include? meth
-
-    index = @accessors.index(meth) + 1 # skip type
-    return self.at(index)
+  def method_missing(meth, delete=false)
+    matches = find_all { | sexp | Sexp === sexp and sexp.first == meth }
+
+    case matches.size
+    when 0 then
+      nil
+    when 1 then
+      match = matches.first
+      delete match if delete
+      match
+    else
+      raise NoMethodError, "multiple nodes for #{meth} were found in #{inspect}"
+    end
   end
 
   def pretty_print(q) # :nodoc:

data/lib/sexp_processor.rb

@@ -121,11 +121,6 @@ class SexpProcessor
 
   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
@@ -142,7 +137,6 @@ class SexpProcessor
     @debug = {}
     @expected = Sexp
     @require_empty = true
-    @sexp_accessors = {}
     @exceptions = {}
 
     # we do this on an instance basis so we can subclass it for
@@ -189,14 +183,6 @@ class SexpProcessor
     exp_orig = exp.deep_clone if $DEBUG or
       @debug.has_key? type or @exceptions.has_key?(type)
 
-    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 UnsupportedNodeError, "'#{type}' is not a supported node type" if @unsupported.include? type
 
     # do a pass through the rewriter first, if any, reassign back to exp

data/test/pt_testcase.rb

@@ -36,6 +36,26 @@ class ParseTreeTestCase < Test::Unit::TestCase
     Unique.reset
   end
 
+  def self.add_test name, data, klass = self.name[4..-1]
+    name = name.to_s
+    klass = klass.to_s
+    if testcases.has_key? name then
+      if testcases[name].has_key? klass then
+        warn "testcase #{klass}##{name} already has data"
+      else
+        testcases[name][klass] = data
+      end
+    else
+      warn "testcase #{name} does not exist"
+    end
+  end
+
+  def self.unsupported_tests *tests
+    tests.flatten.each do |name|
+      add_test name, :unsupported
+    end
+  end
+
   @@testcase_order = %w(Ruby ParseTree)
 
   @@testcases = {
@@ -44,7 +64,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "Ruby"        => "class X\n  alias :y :x\nend",
       "ParseTree"   => [:class, :X, nil,
                         [:scope, [:alias, [:lit, :y], [:lit, :x]]]],
-      "Ruby2Ruby"   => "class X\n  alias_method :y, :x\n  \nend", # FIX dbl \n
+      "Ruby2Ruby"   => "class X\n  alias_method :y, :x\nend", # FIX dbl \n
     },
 
     "and"  => {
@@ -52,19 +72,6 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:and, [:vcall, :a], [:vcall, :b]],
     },
 
-    "args" => {
-      "Ruby"      => "def x(a, b = 42, \*c, &d)\n  p(a, b, c, d)\nend",
-      "ParseTree" => [:defn, :x,
-                      [:scope,
-                       [:block,
-                        [:args, :a, :b, "*c".intern, # s->e
-                         [:block, [:lasgn, :b, [:lit, 42]]]],
-                         [:block_arg, :d],
-                        [:fcall, :p,
-                         [:array, [:lvar, :a], [:lvar, :b],
-                          [:lvar, :c], [:lvar, :d]]]]]]
-    },
-    
     "argscat"  => {
       "Ruby"        => "a = b, c, *d",
       "ParseTree"   => [:lasgn, :a,
@@ -186,32 +193,44 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:cdecl, :X, [:lit, 42]],
     },
 
-    "class"  => {
-      "Ruby"        => "class X < Array\n  def blah\n    puts(\"hello\")\n  end\n  \nend",
+    "class_plain"  => {
+      "Ruby"        => "class X\n  puts((1 + 1))\n  def blah\n    puts(\"hello\")\n  end\nend",
       "ParseTree"   => [:class,
                         :X,
-                        [:const, :Array],
+                        nil,
                         [:scope,
-                         [:defn,
-                          :blah,
-                          [:scope,
-                           [:block,
-                            [:args],
-                            [:fcall, :puts, [:array, [:str, "hello"]]]]]]]],
+                         [:block,
+                          [:fcall, :puts, [:array, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]],
+                          [:defn,
+                           :blah,
+                           [:scope,
+                            [:block,
+                             [:args],
+                             [:fcall, :puts, [:array, [:str, "hello"]]]]]]]]],
     },
 
-    "class_obj"  => {
-      "Ruby"        => "class X\n  def blah\n    puts(\"hello\")\n  end\n  \nend",
+    "class_super_object"  => {
+      "Ruby"        => "class X < Object\nend",
       "ParseTree"   => [:class,
                         :X,
-                        nil,
-                        [:scope,
-                         [:defn,
-                          :blah,
-                          [:scope,
-                           [:block,
-                            [:args],
-                            [:fcall, :puts, [:array, [:str, "hello"]]]]]]]],
+                        [:const, :Object],
+                        [:scope]],
+    },
+
+    "class_super_array"  => {
+      "Ruby"        => "class X < Array\nend",
+      "ParseTree"   => [:class,
+                        :X,
+                        [:const, :Array],
+                        [:scope]],
+    },
+
+    "class_super_expr"  => {
+      "Ruby"        => "class X < expr\nend",
+      "ParseTree"   => [:class,
+                        :X,
+                        [:vcall, :expr],
+                        [:scope]],
     },
 
     "colon2"  => {
@@ -256,6 +275,12 @@ class ParseTreeTestCase < Test::Unit::TestCase
                          [:call, [:lit, 42], :<, [:array, [:lit, 0]]],
                          [:return, [:lit, 3]],
                          [:return, [:lit, 4]]]],
+      "Ruby2Ruby"   => "if (42 == 0) then\n  return 2\nelse\n  if (42 < 0) then\n    return 3\n  else\n    return 4\n  end\nend",
+    },
+
+    "conditional5" => {
+      "Ruby"       => "unless true then\n  if false then\n    return\n  end\nend",
+      "ParseTree"  => [:if, [:true], nil, [:if, [:false], [:return], nil]],
     },
 
     "const"  => {
@@ -276,7 +301,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "cvdecl"  => {
-      "Ruby"        => "class X\n  @@blah = 1\n  \nend",
+      "Ruby"        => "class X\n  @@blah = 1\nend",
       "ParseTree"   => [:class, :X, nil,
                         [:scope, [:cvdecl, :@@blah, [:lit, 1]]]],
     },
@@ -298,6 +323,19 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:defined, [:gvar, :$x]],
     },
 
+    "defn_args" => {
+      "Ruby"      => "def x(a, b = 42, \*c, &d)\n  p(a, b, c, d)\nend",
+      "ParseTree" => [:defn, :x,
+                      [:scope,
+                       [:block,
+                        [:args, :a, :b, "*c".intern, # s->e
+                         [:block, [:lasgn, :b, [:lit, 42]]]],
+                         [:block_arg, :d],
+                        [:fcall, :p,
+                         [:array, [:lvar, :a], [:lvar, :b],
+                          [:lvar, :c], [:lvar, :d]]]]]]
+    },
+    
     "defn_empty" => {
       "Ruby"        => "def empty\n  # do nothing\nend",
       "ParseTree"   => [:defn, :empty, [:scope, [:block, [:args], [:nil]]]],
@@ -308,14 +346,23 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:defn, :something?, [:scope, [:block, [:args], [:nil]]]],
     },
 
+# TODO:
+#   add_test("defn_optargs",
+#            s(:defn, :x,
+#              s(:args, :a, "*args".intern),
+#              s(:scope,
+#                s(:block,
+#                  s(:call, nil, :p,
+#                    s(:arglist, s(:lvar, :a), s(:lvar, :args)))))))
+
     "defn_or" => {
-      "Ruby"        => "def |\n  # do nothing\nend",
-      "ParseTree"   => [:defn, :|, [:scope, [:block, [:args], [:nil]]]],
+      "Ruby"        => "def |(o)\n  # do nothing\nend",
+      "ParseTree"   => [:defn, :|, [:scope, [:block, [:args, :o], [:nil]]]],
     },
     
     "defn_zarray" => { # tests memory allocation for returns
-      "Ruby"        => "def empty\n  a = []\n  return a\nend",
-      "ParseTree"   => [:defn, :empty,
+      "Ruby"        => "def zarray\n  a = []\n  return a\nend",
+      "ParseTree"   => [:defn, :zarray,
                         [:scope,
                          [:block, [:args],
                           [:lasgn, :a, [:zarray]], [:return, [:lvar, :a]]]]],
@@ -391,23 +438,29 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
     
     "ensure" => {
-      "Ruby"        => "def bbegin\n  begin\n    (1 + 1)\n  rescue SyntaxError => e1\n    2\n  rescue Exception => e2\n    3\n  else\n    4\n  ensure\n    5\n  end\nend",
-      "ParseTree"   => [:defn, :bbegin,
-                        [:scope,
-                         [:block,
-                          [:args],
-                          [:begin,
-                           [:ensure,
-                            [:rescue,
-                             [:call, [:lit, 1], :+, [:array, [:lit, 1]]],
-                             [:resbody,
-                              [:array, [:const, :SyntaxError]],
-                              [:block, [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
-                              [:resbody,
-                               [:array, [:const, :Exception]],
-                               [:block, [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
-                             [:lit, 4]],
-                            [:lit, 5]]]]]],
+      "Ruby"        => "begin
+  (1 + 1)
+rescue SyntaxError => e1
+  2
+rescue Exception => e2
+  3
+else
+  4
+ensure
+  5
+end",
+      "ParseTree"   => [:begin,
+                        [:ensure,
+                         [:rescue,
+                          [:call, [:lit, 1], :+, [:array, [:lit, 1]]],
+                          [:resbody,
+                           [:array, [:const, :SyntaxError]],
+                           [:block, [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
+                           [:resbody,
+                            [:array, [:const, :Exception]],
+                            [:block, [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
+                          [:lit, 4]],
+                         [:lit, 5]]],
     },
 
     "false" => {
@@ -652,7 +705,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "module"  => {
-      "Ruby"        => "module X\n  def y\n    # do nothing\n  end\n  \nend",
+      "Ruby"        => "module X\n  def y\n    # do nothing\n  end\nend",
       "ParseTree"   => [:module, :X,
                         [:scope,
                          [:defn, :y, [:scope, [:block, [:args], [:nil]]]]]],
@@ -739,16 +792,21 @@ class ParseTreeTestCase < Test::Unit::TestCase
                         [:fcall, :loop], nil, [:if, [:false], [:redo], nil]],
     },
 
-#     "rescue"  => { # TODO: expression style rescues
-#       "Ruby"        => "blah rescue nil",
-#       "ParseTree"   => [:rescue, [:vcall, :blah], [:resbody, nil, [:nil]]],
-#     },
+    "rescue"  => {
+      "Ruby"        => "blah rescue nil",
+      "ParseTree"   => [:rescue, [:vcall, :blah], [:resbody, nil, [:nil]]],
+    },
 
-    "rescue_block"  => {
+    "rescue_block_nada"  => {
       "Ruby"        => "begin\n  blah\nrescue\n  # do nothing\nend\n",
       "ParseTree"   => [:begin, [:rescue, [:vcall, :blah], [:resbody, nil]]]
     },
 
+    "rescue_block_body"  => {
+      "Ruby"        => "begin\n  blah\nrescue\n  nil\nend\n",
+      "ParseTree"   => [:begin, [:rescue, [:vcall, :blah], [:resbody, nil, [:nil]]]],
+    },
+
     "rescue_exceptions"  => {
       "Ruby"        => "begin\n  blah\nrescue RuntimeError => r\n  # do nothing\nend\n",
       "ParseTree"   => [:begin,
@@ -774,6 +832,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:fcall, :a, [:splat, [:vcall, :b]]],
     },
 
+    # TODO: all supers need to pass args
     "super"  => {
       "Ruby"        => "def x\n  super(4)\nend",
       "ParseTree"   => [:defn, :x,
@@ -823,12 +882,18 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "Ruby2Ruby"   => "undef :x\nundef :y\nundef :z\n",
     },
 
-    "until"  => {
+    "until_pre"  => {
       "Ruby"        => "until false do\n  (1 + 1)\nend",
       "ParseTree"   => [:until, [:false],
                         [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
     },
 
+    "until_post"  => {
+      "Ruby"        => "begin\n  (1 + 1)\nend until false",
+      "ParseTree"   => [:until, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
+    },
+
     "valias"  => {
       "Ruby"        => "alias $y $x",
       "ParseTree"   => [:valias, :$y, :$x],
@@ -839,17 +904,21 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:vcall, :method],
     },
 
-    "whiles" => {
-      "Ruby"        => "def whiles\n  while false do\n    puts(\"false\")\n  end\n  begin\n    puts(\"true\")\n  end while false\nend",
-      "ParseTree"   => [:defn,
-                        :whiles,
-                        [:scope,
-                         [:block,
-                          [:args],
-                          [:while, [:false],
-                           [:fcall, :puts, [:array, [:str, "false"]]], true],
-                          [:while, [:false],
-                           [:fcall, :puts, [:array, [:str, "true"]]], false]]]],
+    "while_pre" => {
+      "Ruby"        => "while false do\n  (1 + 1)\nend",
+      "ParseTree"   => [:while, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], true],
+    },
+
+    "while_pre_nil" => {
+      "Ruby"        => "while false do\nend",
+      "ParseTree"   => [:while, [:false], nil, true],
+    },
+
+    "while_post" => {
+      "Ruby"        => "begin\n  (1 + 1)\nend while false",
+      "ParseTree"   => [:while, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
     },
 
     "xstr" => {
@@ -912,8 +981,8 @@ class ParseTreeTestCase < Test::Unit::TestCase
 #     flunk
 #   end
 
-  def self.previous(key)
-    idx = @@testcase_order.index(key)-1
+  def self.previous(key, extra=0)
+    idx = @@testcase_order.index(key)-1-extra
     case key
     when "RubyToRubyC" then
       idx -= 1
@@ -921,36 +990,42 @@ class ParseTreeTestCase < Test::Unit::TestCase
     @@testcase_order[idx]
   end
 
-  # lets us used unprocessed :self outside of tests, called when subclassed
-  def self.clone_same
-    @@testcases.each do |node, data|
-      data.each do |key, val|
-        if val == :same then
-          prev_key = self.previous(key)
-          data[key] = data[prev_key].deep_clone
-        end
-      end
-    end
-  end
+#   # lets us used unprocessed :self outside of tests, called when subclassed
+#   def self.clone_same
+#     @@testcases.each do |node, data|
+#       data.each do |key, val|
+#         if val == :same then
+#           prev_key = self.previous(key)
+#           data[key] = data[prev_key].deep_clone
+#         end
+#       end
+#     end
+#   end
 
   def self.inherited(c)
-    self.clone_same
-
     output_name = c.name.to_s.sub(/^Test/, '')
     raise "Unknown class #{c}" unless @@testcase_order.include? output_name
 
     input_name = self.previous(output_name)
 
     @@testcases.each do |node, data|
-      next if data[input_name] == :skip
+      next if [:skip, :unsupported].include? data[input_name]
       next if data[output_name] == :skip
 
       c.send(:define_method, "test_#{node}".intern) do
         flunk "Processor is nil" if processor.nil?
         assert data.has_key?(input_name), "Unknown input data"
+        unless data.has_key?(output_name) then
+          $stderr.puts "add_test(#{node.inspect}, :same)"
+        end
         assert data.has_key?(output_name), "Unknown expected data"
         input = data[input_name].deep_clone
-        expected = data[output_name].deep_clone
+
+        expected = if data[output_name] == :same then
+                     input
+                   else
+                     data[output_name]
+                   end.deep_clone
 
         case expected
         when :unsupported then
@@ -964,7 +1039,8 @@ class ParseTreeTestCase < Test::Unit::TestCase
           _, expected, extra_expected = *expected if Array === expected and expected.first == :defx
           _, input, extra_input = *input if Array === input and input.first == :defx
           
-          assert_equal expected, processor.process(input)
+          debug = input.deep_clone
+          assert_equal expected, processor.process(input), "failed on input: #{debug.inspect}"
           extra_input.each do |input| processor.process(input) end
           extra = processor.extra_methods rescue []
           assert_equal extra_expected, extra

data/test/something.rb

@@ -28,11 +28,6 @@ class Something
     5 == unknown_args(4, "known")
   end
 
-  def attrasgn
-    42.method = y
-    self.type = other.type
-  end
-
   # TODO: sort list
   def bbegin
     begin

data/test/test_parse_tree.rb

@@ -37,7 +37,7 @@ class TestParseTree < ParseTreeTestCase
   end
 
   def test_class_initialize
-    expected = [[:class, :SomethingWithInitialize, :Object,
+    expected = [[:class, :SomethingWithInitialize, [:const, :Object],
       [:defn, :initialize, [:scope, [:block, [:args], [:nil]]]],
       [:defn, :protected_meth, [:scope, [:block, [:args], [:nil]]]],
     ]]
@@ -159,7 +159,7 @@ class TestParseTree < ParseTreeTestCase
           :type=, 
           [:array, [:call, [:vcall, :other], :type]]]]]]
   
-  @@__all = [:class, :Something, :Object]
+  @@__all = [:class, :Something, [:const, :Object]]
   
   Something.instance_methods(false).sort.each do |meth|
     if class_variables.include?("@@#{meth}") then

data/test/test_sexp.rb

@@ -59,25 +59,6 @@ class TestSexp < SexpTestCase # ZenTest FULL
 #    raise NotImplementedError, 'Need to write test_class_index'
   end
 
-  def test_accessors; end # handled
-
-  def test_accessors_equals
-    a = s(:call, s(:lit, 1), "func", s(:array, s(:lit, 2)))
-    a.accessors = [:lhs, :name, :rhs]
-
-    assert_equal a.accessors, [:lhs, :name, :rhs]
-
-    assert_equal s(:lit, 1), a.lhs
-    assert_equal "func", a.name
-    assert_equal s(:array, s(:lit, 2)), a.rhs
-
-    a.accessors = []
-
-    assert_raises NoMethodError do
-      a.lhs
-    end
-  end
-
   def test_array_type_eh
     assert_equal false, @sexp.array_type?
     @sexp.unshift :array
@@ -213,15 +194,27 @@ class TestSexp < SexpTestCase # ZenTest FULL
   end
 
   def test_method_missing
+    assert_nil @sexp.not_there
+    assert_equal s(:lit, 42), @basic_sexp.lit
+  end
+
+  def test_method_missing_ambigious
     assert_raises NoMethodError do
-      @sexp.no_such_method
+      pirate = s(:says, s(:arrr!), s(:arrr!), s(:arrr!))
+      pirate.arrr!
     end
+  end
 
-    @sexp.accessors = [:its_a_method_now]
+  def test_method_missing_deep
+    sexp = s(:blah, s(:a, s(:b, s(:c, :yay!))))
+    assert_equal(s(:c, :yay!), sexp.a.b.c)
+  end
 
-    assert_nothing_raised do
-      assert_equal 2, @sexp.its_a_method_now
-    end
+  def test_method_missing_delete
+    sexp = s(:blah, s(:a, s(:b, s(:c, :yay!))))
+
+    assert_equal(s(:c, :yay!), sexp.a.b.c(true))
+    assert_equal(s(:blah, s(:a, s(:b))), sexp)
   end
 
   def test_pretty_print

data/test/test_sexp_processor.rb

@@ -84,30 +84,6 @@ class TestSexpProcessor < Test::Unit::TestCase
     @processor = TestProcessor.new
   end
 
-  def test_sexp_accessors
-    @processor.sexp_accessors = {
-      :acc1 => [:thing_one, :thing_two, :thing_three]
-    }
-
-    a = s(:acc1, 1, 2, 3)
-
-    assert_equal s(:acc2, 3, 2, 1), @processor.process(a)
-  end
-
-  def test_sexp_accessors_reset
-    @processor.sexp_accessors = {
-      :acc1 => [:thing_one, :thing_two, :thing_three]
-    }
-
-    a = s(:acc1, 1, 2, 3)
-    b = @processor.process(a)
-
-    assert_raises NoMethodError do
-      @processor.process(b)
-    end
-  end
-  def test_sexp_accessors=; end # handled
-
   def test_process_specific
     a = [:specific, 1, 2, 3]
     expected = a[1..-1]

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.6.0
-date: 2006-10-11 00:00:00 -07:00
+  version: 1.6.1
+date: 2006-11-13 00:00:00 -05:00
 summary: Extract and enumerate ruby parse trees.
 require_paths: 
 - lib
@@ -75,7 +75,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.1
+        version: 1.1.3
     version: 
 - !ruby/object:Gem::Dependency 
   name: RubyInline