ParseTree 1.6.3 → 1.6.4

data/History.txt

@@ -1,3 +1,11 @@
+*** 1.6.4 / 2007-01-15
+
++ 1 minor enhancement:
+	Switched short if/unless to 1 line expressions.
++ 2 bug fixes:
+ 	Fixed the nested case/when bug. YAY!
+	Added dasgn_curr and defn_rescue test cases.
+
 *** 1.6.3 / 2006-12-20
 
 + 1 bug fix:

data/Rakefile

@@ -7,6 +7,7 @@ $: << "../../RubyInline/dev"
 require './lib/parse_tree.rb'
 
 Hoe.new("ParseTree", ParseTree::VERSION) do |p|
+  p.rubyforge_name = "parsetree"
   p.summary = "Extract and enumerate ruby parse trees."
   p.description = p.paragraphs_of("README.txt", 2).join("\n\n")
   p.changes = p.paragraphs_of("History.txt", 1).join("\n\n")

data/lib/parse_tree.rb

@@ -25,7 +25,7 @@ require 'inline'
 
 class ParseTree
 
-  VERSION = '1.6.3'
+  VERSION = '1.6.4'
 
   ##
   # Front end translation method.
@@ -250,7 +250,7 @@ class ParseTree
 
     builder.prefix %{
         #define nd_3rd   u3.node
-        static VALUE current_case = Qnil;
+        static unsigned case_level = 0;
     }
 
     builder.prefix %{
@@ -378,7 +378,7 @@ again_no_block:
       break;
 
   case NODE_CASE:
-    current_case = current;
+    case_level++;
     if (node->nd_head != NULL) {
       add_to_parse_tree(current, node->nd_head, newlines, locals); /* expr */
     } else {
@@ -396,11 +396,11 @@ again_no_block:
         rb_ary_push(current, Qnil);                     /* no else */
       }
     }
-    current_case = Qnil;
+    case_level--;
     break;
 
   case NODE_WHEN:
-    if (current_case == Qnil) { /* when without case, ie, no expr in case */
+    if (!case_level) { /* 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;

data/test/pt_testcase.rb

@@ -6,21 +6,19 @@ class Examples
   attr_reader :reader
   attr_writer :writer
 
-  def a_method; 1+1; end
+  def a_method(x); x+1; end
   alias an_alias a_method
 
-  def self.bmethod_maker
-    define_method(:bmethod_added) do |x|
-      x + 1
-    end
+  define_method(:unsplatted) do |x|
+    x + 1
   end
 
-  def self.dmethod_maker
-    define_method :dmethod_added, self.method(:bmethod_maker)
-  end if RUBY_VERSION < "1.9"
+  define_method :splatted do |*args|
+    y = args.first
+    y + 42
+  end
 
-  bmethod_maker
-  dmethod_maker if RUBY_VERSION < "1.9"
+  define_method :dmethod_added, instance_method(:a_method) if RUBY_VERSION < "1.9"
 end
 
 class ParseTreeTestCase < Test::Unit::TestCase
@@ -64,7 +62,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\nend", # FIX dbl \n
+      "Ruby2Ruby"   => "class X\n  alias_method :y, :x\nend",
     },
 
     "and"  => {
@@ -132,23 +130,35 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "bmethod"  => {
-      "Ruby"        => [Examples, :bmethod_added],
+      "Ruby"        => [Examples, :unsplatted],
       "ParseTree"   => [:defn,
-                        :bmethod_added,
+                        :unsplatted,
                         [:bmethod,
                          [:dasgn_curr, :x],
                          [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]],
-      "Ruby2Ruby"   => "def bmethod_added(x)\n  (x + 1)\nend"
+      "Ruby2Ruby"   => "def unsplatted(x)\n  (x + 1)\nend"
+    },
+
+    "bmethod_splat" => {
+      "Ruby" => [Examples, :splatted],
+      "ParseTree" => [:defn, :splatted,
+                      [:bmethod,
+                       [:masgn, [:dasgn_curr, :args]],
+                       [:block,
+                        [:dasgn_curr, :y],
+                        [:dasgn_curr, :y, [:call, [:dvar, :args], :first]],
+                        [:call, [:dvar, :y], :+, [:array, [:lit, 42]]]]]],
+      "Ruby2Ruby" => "def splatted(*args)\n  y = args.first\n  (y + 42)\nend",
     },
 
     "break"  => {
-      "Ruby"        => "loop do\n  if true then\n    break\n  end\nend",
+      "Ruby"        => "loop do\n  break if true\nend",
       "ParseTree"   => [:iter,
                         [:fcall, :loop], nil, [:if, [:true], [:break], nil]],
     },
 
     "break_arg"  => {
-      "Ruby"        => "loop do\n  if true then\n    break 42\n  end\nend",
+      "Ruby"        => "loop do\n  break 42 if true\nend",
       "ParseTree"   => [:iter,
                         [:fcall, :loop], nil,
                         [:if, [:true], [:break, [:lit, 42]], nil]],
@@ -197,6 +207,33 @@ class ParseTreeTestCase < Test::Unit::TestCase
                        nil]]
     },
 
+    "case_nested" => {
+      "Ruby"        => "var1 = 1\nvar2 = 2\nresult = nil\ncase var1\nwhen 1 then\n  case var2\n  when 1 then\n    result = 1\n  when 2 then\n    result = 2\n  else\n    result = 3\n  end\nwhen 2 then\n  case var2\n  when 1 then\n    result = 4\n  when 2 then\n    result = 5\n  else\n    result = 6\n  end\nelse\n  result = 7\nend\n",
+      "ParseTree" => [:block,
+                      [:lasgn, :var1, [:lit, 1]],
+                      [:lasgn, :var2, [:lit, 2]],
+                      [:lasgn, :result, [:nil]],
+                      [:case,
+                       [:lvar, :var1],
+                       [:when, [:array, [:lit, 1]],
+                        [:case,
+                         [:lvar, :var2],
+                         [:when, [:array, [:lit, 1]],
+                          [:lasgn, :result, [:lit, 1]]],
+                         [:when, [:array, [:lit, 2]],
+                          [:lasgn, :result, [:lit, 2]]],
+                         [:lasgn, :result, [:lit, 3]]]],
+                       [:when, [:array, [:lit, 2]],
+                        [:case,
+                         [:lvar, :var2],
+                         [:when, [:array, [:lit, 1]],
+                          [:lasgn, :result, [:lit, 4]]],
+                         [:when, [:array, [:lit, 2]],
+                          [:lasgn, :result, [:lit, 5]]],
+                         [:lasgn, :result, [:lit, 6]]]],
+                       [:lasgn, :result, [:lit, 7]]]]
+    },
+
     "case_no_expr" => { # TODO: nested
       "Ruby" => "case\nwhen 1 then\n  :a\nwhen 2 then\n  :b\nelse\n  :c\nend",
       "ParseTree" => [:case, nil,
@@ -263,16 +300,16 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:colon3, :X],
     },
 
-    "conditional1" => {
-      "Ruby"        => "if (42 == 0) then\n  return 1\nend",
+    "conditional1" => { # TODO: rename
+      "Ruby"        => "return 1 if (42 == 0)",
       "ParseTree"   => [:if,
                         [:call, [:lit, 42], :==, [:array, [:lit, 0]]],
                         [:return, [:lit, 1]],
                         nil],
     },
 
-    "conditional2" => {
-      "Ruby"        => "unless (42 == 0) then\n  return 2\nend",
+    "conditional2" => { # TODO: remove
+      "Ruby"        => "return 2 unless (42 == 0)",
       "ParseTree"   => [:if,
                         [:call, [:lit, 42], :==, [:array, [:lit, 0]]],
                         nil,
@@ -299,7 +336,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "conditional5" => {
-      "Ruby"       => "unless true then\n  if false then\n    return\n  end\nend",
+      "Ruby"       => "return if false unless true",
       "ParseTree"  => [:if, [:true], nil, [:if, [:false], [:return], nil]],
     },
 
@@ -338,6 +375,18 @@ class ParseTreeTestCase < Test::Unit::TestCase
                           [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]],
     },
 
+    "dasgn_curr" => {
+      "Ruby"        => "data.each do |x, y|\n  a = 1\n  b = a\n  b = a = x\nend",
+      "ParseTree"   => [:iter,
+                        [:call, [:vcall, :data], :each],
+                        [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]]],
+                        [:block,
+                         [:dasgn_curr, :a, [:dasgn_curr, :b]],
+                         [:dasgn_curr, :a, [:lit, 1]],
+                         [:dasgn_curr, :b, [:dvar, :a]],
+                         [:dasgn_curr, :b, [:dasgn_curr, :a, [:dvar, :x]]]]],
+    },
+
     "defined"  => {
       "Ruby"        => "defined? $x",
       "ParseTree"   => [:defined, [:gvar, :$x]],
@@ -380,6 +429,15 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:defn, :|, [:scope, [:block, [:args, :o], [:nil]]]],
     },
 
+    "defn_rescue" => {
+      "Ruby" => "def blah\n    42\n  rescue\n    24\nend",
+      "ParseTree" => [:defn, :blah,
+                      [:scope, [:block, [:args],
+                                [:rescue,
+                                 [:lit, 42],
+                                 [:resbody, nil, [:lit, 24]]]]]],
+    },
+
     "defn_zarray" => { # tests memory allocation for returns
       "Ruby"        => "def zarray\n  a = []\n  return a\nend",
       "ParseTree"   => [:defn, :zarray,
@@ -402,15 +460,11 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:defn,
                         :dmethod_added,
                         [:dmethod,
-                         :bmethod_maker,
+                         :a_method,
                          [:scope,
                           [:block,
-                           [:args],
-                           [:iter,
-                            [:fcall, :define_method,
-                             [:array, [:lit, :bmethod_added]]],
-                            [:dasgn_curr, :x],
-                            [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]],
+                           [:args, :x],
+                           [:call, [:lvar, :x], :+, [:array, [:lit, 1]]]]]]],
       "Ruby2Ruby" => "def dmethod_added(x)\n  (x + 1)\nend"
     },
 
@@ -494,9 +548,9 @@ end",
                       [:fbody,
                        [:scope,
                         [:block,
-                         [:args],
-                         [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]]]],
-      "Ruby2Ruby" => "def an_alias\n  (1 + 1)\nend"
+                         [:args, :x],
+                         [:call, [:lvar, :x], :+, [:array, [:lit, 1]]]]]]],
+      "Ruby2Ruby" => "def an_alias(x)\n  (x + 1)\nend"
     },
 
     "fcall"  => {
@@ -716,7 +770,7 @@ end",
                         [:array,  [:vcall, :c], [:vcall, :d]]],
     },
     "match"  => {
-      "Ruby"        => "if /x/ then\n  1\nend",
+      "Ruby"        => "1 if /x/",
       "ParseTree"   => [:if, [:match, [:lit, /x/]], [:lit, 1], nil],
     },
 
@@ -738,7 +792,7 @@ end",
     },
 
     "next"  => {
-      "Ruby"        => "loop do\n  if false then\n    next\n  end\nend",
+      "Ruby"        => "loop do\n  next if false\nend",
       "ParseTree"   => [:iter,
                         [:fcall, :loop],
                         nil,
@@ -829,7 +883,7 @@ end",
     },
 
     "redo"  => {
-      "Ruby"        => "loop do\n  if false then\n    redo\n  end\nend",
+      "Ruby"        => "loop do\n  redo if false\nend",
       "ParseTree"   => [:iter,
                         [:fcall, :loop], nil, [:if, [:false], [:redo], nil]],
     },

data/test/test_parse_tree.rb

@@ -147,20 +147,20 @@ class TestParseTree < ParseTreeTestCase
                 :unknown_args,
                 [:array, [:lit, 4], [:str, "known"]]]]]]]]
 
-  
+
   @@attrasgn = [:defn,
     :attrasgn,
     [:scope,
       [:block,
         [:args],
         [:attrasgn, [:lit, 42], :method=, [:array, [:vcall, :y]]],
-        [:attrasgn, 
+        [:attrasgn,
           [:self],
-          :type=, 
+          :type=,
           [:array, [:call, [:vcall, :other], :type]]]]]]
-  
+
   @@__all = [:class, :Something, [:const, :Object]]
-  
+
   Something.instance_methods(false).sort.each do |meth|
     if class_variables.include?("@@#{meth}") then
       @@__all << eval("@@#{meth}")
@@ -171,6 +171,7 @@ class TestParseTree < ParseTreeTestCase
   end
 
   Something.singleton_methods.sort.each do |meth|
+    next if meth =~ /yaml/ # rubygems introduced a bug
     if class_variables.include?("@@self_#{meth}") then
       @@__all << eval("@@self_#{meth}")
       eval "def test_self_#{meth}; assert_equal @@self_#{meth}, @processor.parse_tree_for_method(Something, :#{meth}, true); end"
@@ -181,14 +182,13 @@ class TestParseTree < ParseTreeTestCase
 
   def test_missing
     assert_equal(@@missing,
-		 @processor.parse_tree_for_method(Something, :missing),
-		 "Must return -3 for missing methods")
+                 @processor.parse_tree_for_method(Something, :missing),
+                 "Must return -3 for missing methods")
   end
 
   def test_whole_class
     assert_equal([@@__all],
-		 @processor.parse_tree(Something),
-		 "Must return a lot of shit")
+                 @processor.parse_tree(Something),
+                 "Must return a lot of shit")
   end
 end
-

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.0.9
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.6.3
-date: 2006-12-20 00:00:00 -08:00
+  version: 1.6.4
+date: 2007-01-15 00:00:00 -08:00
 summary: Extract and enumerate ruby parse trees.
 require_paths: 
 - lib
@@ -69,20 +69,20 @@ requirements: []
 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: RubyInline
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.4
+        version: 3.2.0
     version: 
 - !ruby/object:Gem::Dependency 
-  name: RubyInline
+  name: hoe
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.2.0
+        version: 1.1.7
     version: