ParseTree 1.6.1 → 1.6.2

data/History.txt

@@ -1,3 +1,11 @@
+*** 1.6.2 / 2006-12-19
+
++ 2 minor enhancements:
+	+ ParseTree::translate can now take :"self.method".
+	* Improved PT tests for [], []=
++ 1 bug fixes:
+	* Fixed a bug in ParseTree where cases w/o exprs were malformed.
+
 *** 1.6.1 / 2006-11-11
 
 + 2 minor enhancements:

data/Rakefile

@@ -12,7 +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 }
+  p.spec_extras[:require_paths] = proc { |paths| paths << 'test' }
 end
 
 desc 'Run against ruby 1.9 (from a multiruby install) with -d.'

data/lib/parse_tree.rb

@@ -25,10 +25,10 @@ require 'inline'
 
 class ParseTree
 
-  VERSION = '1.6.1'
+  VERSION = '1.6.2'
 
   ##
-  # Front end translation method. 
+  # Front end translation method.
 
   def self.translate(klass_or_str, method=nil)
     pt = self.new(false)
@@ -37,7 +37,12 @@ class ParseTree
       pt.parse_tree_for_string(klass_or_str).first
     else
       unless method.nil? then
-        pt.parse_tree_for_method(klass_or_str, method)
+        if method.to_s =~ /^self\./ then
+          method = method.to_s[5..-1].intern
+          pt.parse_tree_for_method(klass_or_str, method, true)
+        else
+          pt.parse_tree_for_method(klass_or_str, method)
+        end
       else
         pt.parse_tree(klass_or_str).first
       end
@@ -245,6 +250,7 @@ class ParseTree
 
     builder.prefix %{
         #define nd_3rd   u3.node
+        static VALUE current_case = Qnil;
     }
 
     builder.prefix %{
@@ -372,12 +378,17 @@ again_no_block:
       break;
 
   case NODE_CASE:
-    add_to_parse_tree(current, node->nd_head, newlines, locals); /* expr */
+    current_case = current;
+    if (node->nd_head != NULL) {
+      add_to_parse_tree(current, node->nd_head, newlines, locals); /* expr */
+    } else {
+      rb_ary_push(current, Qnil);
+    }
     node = node->nd_body;
     while (node) {
       add_to_parse_tree(current, node, newlines, locals);
       if (nd_type(node) == NODE_WHEN) {                 /* when */
-        node = node->nd_next; 
+        node = node->nd_next;
       } else {
         break;                                          /* else */
       }
@@ -385,9 +396,15 @@ again_no_block:
         rb_ary_push(current, Qnil);                     /* no else */
       }
     }
+    current_case = Qnil;
     break;
 
   case NODE_WHEN:
+    if (current_case == Qnil) { /* when without case, ie, no expr in case */
+      rb_ary_pop(ary); /* reset what current is pointing at */
+      node = NEW_CASE(0, node);
+      goto again;
+    }
     add_to_parse_tree(current, node->nd_head, newlines, locals); /* args */
     if (node->nd_body) {
       add_to_parse_tree(current, node->nd_body, newlines, locals); /* body */
@@ -400,7 +417,7 @@ again_no_block:
   case NODE_UNTIL:
     add_to_parse_tree(current,  node->nd_cond, newlines, locals);
     if (node->nd_body) {
-      add_to_parse_tree(current,  node->nd_body, newlines, locals); 
+      add_to_parse_tree(current,  node->nd_body, newlines, locals);
     } else {
       rb_ary_push(current, Qnil);
     }
@@ -439,7 +456,7 @@ again_no_block:
     break;
 
   // rescue body:
-  // begin stmt rescue exception => var; stmt; [rescue e2 => v2; s2;]* end 
+  // begin stmt rescue exception => var; stmt; [rescue e2 => v2; s2;]* end
   // stmt rescue stmt
   // a = b rescue c
 
@@ -452,7 +469,7 @@ again_no_block:
       add_to_parse_tree(current, node->nd_2nd, newlines, locals);
       add_to_parse_tree(current, node->nd_1st, newlines, locals);
     break;
-	
+
   case NODE_ENSURE:
     add_to_parse_tree(current, node->nd_head, newlines, locals);
     if (node->nd_ensr) {
@@ -575,7 +592,7 @@ again_no_block:
     add_to_parse_tree(current, node->nd_head, newlines, locals);
     if (node->nd_args) {
       if (node->nd_args != (NODE *)-1) {
-	add_to_parse_tree(current, node->nd_args, newlines, locals);
+        add_to_parse_tree(current, node->nd_args, newlines, locals);
       }
     }
     add_to_parse_tree(current, node->nd_value, newlines, locals);
@@ -613,22 +630,22 @@ again_no_block:
   case NODE_HASH:
     {
       NODE *list;
-	
+
       list = node->nd_head;
       while (list) {
-	add_to_parse_tree(current, list->nd_head, newlines, locals);
-	list = list->nd_next;
-	if (list == 0)
-	  rb_bug("odd number list for Hash");
-	add_to_parse_tree(current, list->nd_head, newlines, locals);
-	list = list->nd_next;
+        add_to_parse_tree(current, list->nd_head, newlines, locals);
+        list = list->nd_next;
+        if (list == 0)
+          rb_bug("odd number list for Hash");
+        add_to_parse_tree(current, list->nd_head, newlines, locals);
+        list = list->nd_next;
       }
     }
     break;
 
   case NODE_ARRAY:
       while (node) {
-	add_to_parse_tree(current, node->nd_head, newlines, locals);
+        add_to_parse_tree(current, node->nd_head, newlines, locals);
         node = node->nd_next;
       }
     break;
@@ -642,20 +659,20 @@ again_no_block:
       NODE *list = node->nd_next;
       rb_ary_push(current, rb_str_new3(node->nd_lit));
       while (list) {
-	if (list->nd_head) {
-	  switch (nd_type(list->nd_head)) {
-	  case NODE_STR:
-	    add_to_parse_tree(current, list->nd_head, newlines, locals);
-	    break;
-	  case NODE_EVSTR:
-	    add_to_parse_tree(current, list->nd_head->nd_body, newlines, locals);
-	    break;
-	  default:
-	    add_to_parse_tree(current, list->nd_head, newlines, locals);
-	    break;
-	  }
-	}
-	list = list->nd_next;
+        if (list->nd_head) {
+          switch (nd_type(list->nd_head)) {
+          case NODE_STR:
+            add_to_parse_tree(current, list->nd_head, newlines, locals);
+            break;
+          case NODE_EVSTR:
+            add_to_parse_tree(current, list->nd_head->nd_body, newlines, locals);
+            break;
+          default:
+            add_to_parse_tree(current, list->nd_head, newlines, locals);
+            break;
+          }
+        }
+        list = list->nd_next;
       }
     }
     break;
@@ -664,7 +681,7 @@ again_no_block:
   case NODE_DEFS:
     if (node->nd_defn) {
       if (nd_type(node) == NODE_DEFS)
-	add_to_parse_tree(current, node->nd_recv, newlines, locals);
+        add_to_parse_tree(current, node->nd_recv, newlines, locals);
       rb_ary_push(current, ID2SYM(node->nd_mid));
       add_to_parse_tree(current, node->nd_defn, newlines, locals);
     }
@@ -705,8 +722,8 @@ again_no_block:
       while (optnode) {
         // optional arg names
         rb_ary_push(current, ID2SYM(locals[i + 3]));
-	i++;
-	optnode = optnode->nd_next;
+        i++;
+        optnode = optnode->nd_next;
       }
 
       if (arg_count > 0) {
@@ -727,11 +744,11 @@ again_no_block:
       optnode = node->nd_opt;
       // block?
       if (optnode) {
-	add_to_parse_tree(current, node->nd_opt, newlines, locals);
+        add_to_parse_tree(current, node->nd_opt, newlines, locals);
       }
     }
   }  break;
-	
+
   case NODE_LVAR:
   case NODE_DVAR:
   case NODE_IVAR:

data/test/pt_testcase.rb

@@ -14,11 +14,11 @@ class Examples
       x + 1
     end
   end
-  
+
   def self.dmethod_maker
     define_method :dmethod_added, self.method(:bmethod_maker)
   end if RUBY_VERSION < "1.9"
-  
+
   bmethod_maker
   dmethod_maker if RUBY_VERSION < "1.9"
 end
@@ -59,7 +59,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
   @@testcase_order = %w(Ruby ParseTree)
 
   @@testcases = {
-    
+
     "alias"  => {
       "Ruby"        => "class X\n  alias :y :x\nend",
       "ParseTree"   => [:class, :X, nil,
@@ -87,7 +87,6 @@ class ParseTreeTestCase < Test::Unit::TestCase
                         [:vcall, :a],
                         :[]=,
                         [:argspush, [:splat, [:vcall, :b]], [:vcall, :c]]],
-      "Ruby2Ruby"   => "a.[]=(*b, c)" # HACK until we can get things ironed out
     },
 
     "array"  => {
@@ -96,18 +95,23 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "attrasgn" => {
-      "Ruby"        => "y = 0\n42.method=(y)\n",
+      "Ruby"        => "y = 0\n42.method = y\n",
       "ParseTree"   => [:block,
                         [:lasgn, :y, [:lit, 0]],
                         [:attrasgn, [:lit, 42], :method=, [:array, [:lvar, :y]]]],
     },
 
+    "attrasgn_index_equals" => {
+      "Ruby"        => "a[42] = 24",
+      "ParseTree"   => [:attrasgn, [:vcall, :a], :[]=, [:array, [:lit, 42], [:lit, 24]]],
+    },
+
     "attrset" => {
       "Ruby"        => [Examples, :writer=],
       "ParseTree"   => [:defn, :writer=, [:attrset, :@writer]],
       "Ruby2Ruby"   => "attr_writer :writer"
     },
-    
+
     "back_ref"  => {
       "Ruby"        => "[$&, $`, $', $+]",
       "ParseTree"   => [:array,
@@ -116,7 +120,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
                         [:back_ref, "'".intern], # s->e
                         [:back_ref, :+]],
     },
-    
+
     "begin"  => {
       "Ruby"        => "begin\n  (1 + 1)\nend",
       "ParseTree"   => [:begin, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
@@ -142,14 +146,14 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:iter,
                         [:fcall, :loop], nil, [:if, [:true], [:break], nil]],
     },
-    
+
     "break_arg"  => {
       "Ruby"        => "loop do\n  if true then\n    break 42\n  end\nend",
       "ParseTree"   => [:iter,
                         [:fcall, :loop], nil,
                         [:if, [:true], [:break, [:lit, 42]], nil]],
     },
-    
+
     "call" => {
       "Ruby"        => "self.method",
       "ParseTree" => [:call, [:self], :method],
@@ -160,6 +164,11 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:fcall, :puts, [:array, [:lit, 42]]],
     },
 
+    "call_index" => { # see attrasgn_index_equals for opposite
+      "Ruby"        => "a[42]",
+      "ParseTree"   => [:call, [:vcall, :a], :[], [:array, [:lit, 42]]],
+    },
+
     "case" => {
       "Ruby"        => "var = 2\nresult = \"\"\ncase var\nwhen 1 then\n  puts(\"something\")\n  result = \"red\"\nwhen 2, 3 then\n  result = \"yellow\"\nwhen 4 then\n  # do nothing\nelse\n  result = \"green\"\nend\ncase result\nwhen \"red\" then\n  var = 1\nwhen \"yellow\" then\n  var = 2\nwhen \"green\" then\n  var = 3\nelse\n  # do nothing\nend\n",
       "ParseTree" => [:block,
@@ -188,6 +197,17 @@ class ParseTreeTestCase < Test::Unit::TestCase
                        nil]]
     },
 
+    "case_no_expr" => { # TODO: nested
+      "Ruby" => "case\nwhen 1 then\n  :a\nwhen 2 then\n  :b\nelse\n  :c\nend",
+      "ParseTree" => [:case, nil,
+                      [:when,
+                       [:array, [:lit, 1]],
+                       [:lit, :a]],
+                      [:when,
+                       [:array, [:lit, 2]], [:lit, :b]],
+                      [:lit, :c]],
+    },
+
     "cdecl"  => {
       "Ruby"        => "X = 42",
       "ParseTree"   => [:cdecl, :X, [:lit, 42]],
@@ -335,7 +355,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
                          [: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]]]],
@@ -359,7 +379,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "Ruby"        => "def |(o)\n  # do nothing\nend",
       "ParseTree"   => [:defn, :|, [:scope, [:block, [:args, :o], [:nil]]]],
     },
-    
+
     "defn_zarray" => { # tests memory allocation for returns
       "Ruby"        => "def zarray\n  a = []\n  return a\nend",
       "ParseTree"   => [:defn, :zarray,
@@ -396,12 +416,12 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
     "dot2"  => {
       "Ruby"        => "(a..b)",
-      "ParseTree"   => [:dot2, [:vcall, :a], [:vcall, :b]], 
+      "ParseTree"   => [:dot2, [:vcall, :a], [:vcall, :b]],
     },
 
     "dot3"  => {
       "Ruby"        => "(a...b)",
-      "ParseTree"   => [:dot3, [:vcall, :a], [:vcall, :b]], 
+      "ParseTree"   => [:dot3, [:vcall, :a], [:vcall, :b]],
     },
 
     "dregx"  => {
@@ -436,7 +456,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
                         [:lasgn, :t, [:lit, 5]],
                         [:dxstr, 'touch ', [:lvar, :t]]],
     },
-    
+
     "ensure" => {
       "Ruby"        => "begin
   (1 + 1)
@@ -686,7 +706,7 @@ end",
       "Ruby"        => "a, b = c, d",
       "ParseTree"   => [:masgn,
                         [:array, [:lasgn, :a], [:lasgn, :b]],
-                        [:array,  [:vcall, :c], [:vcall, :d]]], 
+                        [:array,  [:vcall, :c], [:vcall, :d]]],
     },
 
     "match"  => {
@@ -749,13 +769,13 @@ end",
                           :new, [:array, [:lit, :var]]]],
                         [:lasgn, :c,
                          [:call, [:lvar, :s], :new, [:array, [:nil]]]],
-                        
+
                         [:op_asgn2, [:lvar, :c], :var=, "||".intern, # s->e
                          [:lit, 20]],
                         [:op_asgn2, [:lvar, :c], :var=, "&&".intern, # s->e
                          [:lit, 21]],
                         [:op_asgn2, [:lvar, :c], :var=, :+, [:lit, 22]],
-                        
+
                         [:op_asgn2,
                          [:call,
                           [:call, [:lvar, :c], :d], :e], :f=, "||".intern,
@@ -786,6 +806,22 @@ end",
       "ParseTree"   => [:iter, [:postexe], nil, [:lit, 1]],
     },
 
+    "proc_no_args" => {
+      "Ruby" => "proc do\n  (x + 1)\nend",
+      "ParseTree" => [:iter,
+                      [:fcall, :proc],
+                      nil,
+                      [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
+    },
+
+    "proc_args" => {
+      "Ruby" => "proc do |x|\n  (x + 1)\nend",
+      "ParseTree" => [:iter,
+                      [:fcall, :proc],
+                      [:dasgn_curr, :x],
+                      [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
+    },
+
     "redo"  => {
       "Ruby"        => "loop do\n  if false then\n    redo\n  end\nend",
       "ParseTree"   => [:iter,
@@ -963,7 +999,7 @@ end",
 #       # HACK
 #       nodes -= [:alloca, :argspush, :cfunc, :cref, :evstr, :ifunc, :last, :memo, :newline, :opt_n, :method].map { |s| s.to_s }
 #     end
-    
+
 #     untested = nodes-tested
 
 #     puts
@@ -977,7 +1013,7 @@ end",
 #     },
 # )
 #     end
-    
+
 #     flunk
 #   end
 
@@ -1038,7 +1074,7 @@ end",
 
           _, expected, extra_expected = *expected if Array === expected and expected.first == :defx
           _, input, extra_input = *input if Array === input and input.first == :defx
-          
+
           debug = input.deep_clone
           assert_equal expected, processor.process(input), "failed on input: #{debug.inspect}"
           extra_input.each do |input| processor.process(input) end

metadata

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