ParseTree 1.4.1 → 1.5.0

data/test/something.rb

@@ -1,6 +1,10 @@
 
 class Something
 
+  def self.classmethod
+    1 + 1
+  end
+
   # basically: do we work at all?
   def empty
   end
@@ -56,13 +60,17 @@ class Something
   def iteration1
     array = [1, 2, 3]
     array.each do |x|
-      puts(x.to_s)
+      y = x.to_s
+      puts(y)
     end
   end
 
   def iteration2
     array = [1, 2, 3]
-    array.each { |x| puts(x.to_s) }
+    array.each { |x|
+      y = x.to_s
+      puts(y)
+    }
   end
 
   def iteration3
@@ -185,6 +193,36 @@ class Something
     end
   end
 
+  def bbegin_no_exception
+    begin
+      5
+    rescue
+      6
+    end
+  end
+
+  def op_asgn
+    a = 0
+    a ||= 1
+    a &&= 2
+    #a += 3 # doesn't use op_asgn
+
+    b = []
+    b[1] ||= 10
+    b[2] &&= 11
+    b[3] +=  12
+
+    s = Struct.new :var
+    c = s.new nil
+    c.var ||= 20
+    c.var &&= 21
+    c.var +=  22
+
+    c.d.e.f ||= 42
+
+    return a
+  end
+
   def whiles
     while false do
       puts "false"

data/test/test_parse_tree.rb

@@ -28,8 +28,59 @@ class TestParseTree < Test::Unit::TestCase
     assert_equal expected, tree
   end
 
+  def test_parse_tree_for_string
+    actual   = @thing.parse_tree_for_string '1 + nil', '(string)', 1, false
+    expected = [[:call, [:lit, 1], :+, [:array, [:nil]]]]
+
+    assert_equal expected, actual
+  end
+
+  def test_parse_tree_for_string_with_newlines
+    actual   = @thing.parse_tree_for_string "1 +\n nil", 'test.rb', 5, true
+    expected = [[:newline, 6, "test.rb"],
+                [:call, [:lit, 1], :+, [:array, [:nil]]]]
+
+    assert_equal expected, actual
+  end
+
+  def test_parse_tree_for_str
+    actual   = @thing.parse_tree_for_str '1 + nil', '(string)', 1, false
+    expected = [[:call, [:lit, 1], :+, [:array, [:nil]]]]
+
+    assert_equal expected, actual
+  end
+
   # TODO: need a test of interpolated strings
 
+  @@self_classmethod = [:defn, :"self.classmethod",
+                        [:scope,
+                         [:block,
+                          [:args],
+                          [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]]]
+
+  @@self_bmethod_maker = [:defn,
+                          :"self.bmethod_maker",
+                          [:scope,
+                           [:block,
+                            [:args],
+                            [:iter,
+                             [:fcall, :define_method,
+                              [:array, [:lit, :bmethod_added]]],
+                             [:dasgn_curr, :x],
+                             [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]
+
+  @@self_dmethod_maker = [:defn,
+                          :"self.dmethod_maker",
+                          [:scope,
+                           [:block,
+                            [:args],
+                            [:fcall,
+                             :define_method,
+                             [:array,
+                              [:lit, :dmethod_added],
+                              [:call, [:self], :method,
+                               [:array, [:lit, :bmethod_maker]]]]]]]]
+
   @@missing = [nil]
   @@empty = [:defn, :empty,
     [:scope,
@@ -125,15 +176,19 @@ class TestParseTree < Test::Unit::TestCase
             [:return, [:lit, 3]],
             [:return, [:lit, 4]]]]]]]
   @@iteration_body = [:scope,
-    [:block,
-      [:args],
-      [:lasgn, :array,
-        [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
-      [:iter,
-        [:call,
-          [:lvar, :array], :each],
-        [:dasgn_curr, :x],
-        [:fcall, :puts, [:array, [:call, [:dvar, :x], :to_s]]]]]]
+                   [:block,
+                    [:args],
+                    [:lasgn, :array,
+                     [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
+                    [:iter,
+                     [:call,
+                      [:lvar, :array], :each],
+                     [:dasgn_curr, :x],
+                     [:block,
+                      [:dasgn_curr, :y],
+                      [:dasgn_curr, :y, [:call, [:dvar, :x], :to_s]],
+                      [:fcall, :puts, [:array, [:dvar, :y]]]]]]]
+
   @@iteration1 = [:defn, :iteration1, @@iteration_body]
   @@iteration2 = [:defn, :iteration2, @@iteration_body]
   @@iteration3 = [:defn, :iteration3,
@@ -287,6 +342,38 @@ class TestParseTree < Test::Unit::TestCase
                   [:block, [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
               [:lit, 4]],
             [:lit, 5]]]]]]
+  @@bbegin_no_exception = [:defn, :bbegin_no_exception,
+    [:scope,
+      [:block,
+        [:args],
+        [:begin,
+          [:rescue,
+            [:lit, 5],
+            [:resbody, nil, [:lit, 6]]]]]]]
+  @@op_asgn = [:defn, :op_asgn,
+               [:scope,
+                [:block,
+                 [:args],
+                 [:lasgn, :a, [:lit, 0]],
+                 [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 1]]],
+                 [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 2]]],
+
+                 [:lasgn, :b, [:zarray]],
+
+                 [:op_asgn1, [:lvar, :b], [:array, [:lit, 1]], :"||", [:lit, 10]],
+       [:op_asgn1, [:lvar, :b], [:array, [:lit, 2]], :"&&", [:lit, 11]],
+       [:op_asgn1, [:lvar, :b], [:array, [:lit, 3]], :+, [:lit, 12]],
+
+       [:lasgn, :s, [:call, [:const, :Struct], :new, [:array, [:lit, :var]]]],
+       [:lasgn, :c, [:call, [:lvar, :s], :new, [:array, [:nil]]]],
+
+       [:op_asgn2, [:lvar, :c], :var=, :"||", [:lit, 20]],
+       [:op_asgn2, [:lvar, :c], :var=, :"&&", [:lit, 21]],
+       [:op_asgn2, [:lvar, :c], :var=, :+, [:lit, 22]],
+
+       [:op_asgn2, [:call, [:call, [:lvar, :c], :d], :e], :f=, :"||", [:lit, 42]],
+
+       [:return, [:lvar, :a]]]]]
   @@determine_args = [:defn, :determine_args,
     [:scope,
       [:block,
@@ -335,6 +422,18 @@ class TestParseTree < Test::Unit::TestCase
         [:args],
         [:while, [:false], [:fcall, :puts, [:array, [:str, "false"]]], true],
         [:while, [:false], [:fcall, :puts, [:array, [:str, "true"]]], false]]]]
+  @@xstr = [:defn,
+    :xstr,
+    [:scope,
+      [:block,
+        [:args],
+        [:xstr, 'touch 5']]]] 
+  @@dxstr = [:defn,
+    :dxstr,
+    [:scope,
+      [:block,
+        [:args],
+        [:dxstr, 'touch ', [:lit, 5]]]]] 
 
   @@__all = [:class, :Something, :Object]
   
@@ -342,7 +441,9 @@ class TestParseTree < Test::Unit::TestCase
     @thing = ParseTree.new(false)
   end
 
-  Something.instance_methods(false).sort.each do |meth|
+  methods = Something.instance_methods(false)
+
+  methods.sort.each do |meth|
     if class_variables.include?("@@#{meth}") then
       @@__all << eval("@@#{meth}")
       eval "def test_#{meth}; assert_equal @@#{meth}, @thing.parse_tree_for_method(Something, :#{meth}); end"
@@ -351,6 +452,18 @@ class TestParseTree < Test::Unit::TestCase
     end
   end
 
+  methods = Something.singleton_methods
+
+# TODO: cleanup
+  methods.sort.each do |meth|
+    if class_variables.include?("@@self_#{meth}") then
+      @@__all << eval("@@self_#{meth}")
+      eval "def test_self_#{meth}; assert_equal @@self_#{meth}, @thing.parse_tree_for_method(Something, :#{meth}, true); end"
+    else
+      eval "def test_self_#{meth}; flunk \"You haven't added @@self_#{meth} yet\"; end"
+    end
+  end
+
   def test_missing
     assert_equal(@@missing,
 		 @thing.parse_tree_for_method(Something, :missing),
@@ -362,6 +475,5 @@ class TestParseTree < Test::Unit::TestCase
 		 @thing.parse_tree(Something),
 		 "Must return a lot of shit")
   end
-
 end
 

data/test/test_sexp_processor.rb

@@ -137,6 +137,15 @@ class TestSexpProcessor < Test::Unit::TestCase
     end
   end
 
+  def test_process_unsupported_wrong
+    @processor = TestProcessor.new
+    @processor.unsupported << :strip
+
+    assert_raises(UnsupportedNodeError) do
+      @processor.process([:whatever])
+    end
+  end
+
   def test_unsupported_equal
     @processor.strict = true
     @processor.unsupported = [ :unsupported ]

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11.6
+rubygems_version: 0.9.0
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.4.1
-date: 2006-04-10 00:00:00 -07:00
+  version: 1.5.0
+date: 2006-09-24 00:00:00 -07:00
 summary: Extract and enumerate ruby parse trees.
 require_paths: 
 - lib
@@ -13,7 +13,7 @@ email: ryand-ruby@zenspider.com
 homepage: http://www.zenspider.com/ZSS/Products/ParseTree/
 rubyforge_project: parsetree
 description: ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers.
-autorequire: parse_tree
+autorequire: 
 default_executable: 
 bindir: bin
 has_rdoc: true
@@ -35,6 +35,7 @@ files:
 - Manifest.txt
 - README.txt
 - bin/parse_tree_abc
+- bin/parse_tree_audit
 - bin/parse_tree_deps
 - bin/parse_tree_show
 - demo/printer.rb
@@ -42,6 +43,7 @@ files:
 - lib/parse_tree.rb
 - lib/sexp.rb
 - lib/sexp_processor.rb
+- test/pt_testcase.rb
 - test/something.rb
 - test/test_all.rb
 - test/test_composite_sexp_processor.rb
@@ -57,6 +59,7 @@ extra_rdoc_files: []
 
 executables: 
 - parse_tree_abc
+- parse_tree_audit
 - parse_tree_deps
 - parse_tree_show
 extensions: []
@@ -64,6 +67,15 @@ extensions: []
 requirements: []
 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
 - !ruby/object:Gem::Dependency 
   name: RubyInline
   version_requirement: