ParseTree 1.7.1 → 2.0.0

data/test/test_parse_tree.rb

@@ -89,7 +89,8 @@ class TestParseTree < ParseTreeTestCase
     assert_equal expected, actual
   end
 
-  @@self_classmethod = [:defn, :"self.classmethod",
+  @@self_classmethod = [:defs,
+                        [:self], :classmethod,
                         [:scope,
                          [:block,
                           [:args],

data/test/test_sexp.rb

@@ -17,6 +17,11 @@ class SexpTestCase < Test::Unit::TestCase
 
   include SexpMatchSpecials
 
+  def util_equals(x, y)
+    result = x == y
+    assert_not_nil result, "#{x.inspect} does not === #{y.inspect}"
+  end
+
   def util_equals3(x, y)
     result = x === y
     assert_not_nil result, "#{x.inspect} does not === #{y.inspect}"
@@ -33,6 +38,12 @@ end
 
 class TestSexp < SexpTestCase # ZenTest FULL
 
+  class SexpFor
+    def method
+      1
+    end
+  end
+
   def util_pretty_print(expect, input)
     io = StringIO.new
     PP.pp(input, io)
@@ -51,6 +62,14 @@ class TestSexp < SexpTestCase # ZenTest FULL
     @bad1 = s(:blah, 42)
   end
 
+  def test_class_for
+    sexp = Sexp.for SexpFor
+    assert_equal s(:class, :"TestSexp::SexpFor"), sexp[0..1]
+
+    sexp = Sexp.for SexpFor, :method
+    assert_equal s(:defn, :method), sexp[0..1]
+  end
+
   def test_class_from_array
 #    raise NotImplementedError, 'Need to write test_class_from_array'
   end
@@ -89,7 +108,7 @@ class TestSexp < SexpTestCase # ZenTest FULL
     sexp2 = s(1, 2, 5)
     assert_not_equal(@sexp, sexp2)
   end
- 
+
   def test_equals2_sexp
     sexp2 = s(1, 2, 3)
     if @sexp.class == Sexp then
@@ -142,14 +161,14 @@ class TestSexp < SexpTestCase # ZenTest FULL
 
     util_equals3 s(:a), s(:blah, s(:blah, s(:a)))       # left deeper
   end
-  
+
 #   def test_equalstilde_any
 #     result = @basic_sexp =~ s(:lit, ANY())
 #     p result
 #     assert result
 #   end
 
-  def test_equalstilde_fancy   
+  def test_equalstilde_fancy
     assert_nil     s(:b) =~ s(:a, s(:b), :c)
     assert_not_nil s(:a, s(:b), :c) =~ s(:b)
   end
@@ -282,6 +301,12 @@ class TestSexpAny < SexpTestCase
     super
   end
 
+  def test_equals
+    util_equals @any, s()
+    util_equals @any, s(:a)
+    util_equals @any, s(:a, :b, s(:c))
+  end
+
   def test_equals3
     util_equals3 @any, s()
     util_equals3 @any, s(:a)

data/test/test_sexp_processor.rb

@@ -24,9 +24,12 @@ class TestProcessor < SexpProcessor # ZenTest SKIP
   end
 
   def process_specific(exp)
-    result = exp[1..-1]
-    exp.clear
-    self.expected.new(*result)
+    name = exp.shift
+    result = s(:blah)
+    until exp.empty?
+      result.push process(exp.shift)
+    end
+    result
   end
 
   def process_strip(exp)
@@ -59,7 +62,20 @@ class TestProcessor < SexpProcessor # ZenTest SKIP
   end
 
   def process_rewritable(exp)
-    return s(exp.shift, exp.shift == 2, exp.shift == 1)
+    @n ||= 0
+    exp.shift # name
+    result = s(:rewritten)
+    until exp.empty?
+      result.push process(exp.shift)
+    end
+    result.push @n
+    @n += 1
+    result
+  end
+
+  def rewrite_major_rewrite(exp)
+    exp[0] = :rewritable
+    exp
   end
 end
 
@@ -84,12 +100,12 @@ class TestSexpProcessor < Test::Unit::TestCase
   end
 
   def test_process_specific
-    a = [:specific, 1, 2, 3]
-    expected = a[1..-1]
+    a = [:specific, [:x, 1], [:y, 2], [:z, 3]]
+    expected = [:blah, [:x, 1], [:y, 2], [:z, 3]]
     assert_equal(expected, @processor.process(a))
   end
 
-  def test_process_general
+  def test_process_generic
     a = [:blah, 1, 2, 3]
     expected = a.deep_clone
     assert_equal(expected, @processor.process(a))
@@ -162,25 +178,66 @@ class TestSexpProcessor < Test::Unit::TestCase
                  @processor.rewrite(s(:rewritable, :a, :b)))
   end
 
+  def test_rewrite_different_type
+    assert_equal(s(:rewritable, :b, :a),
+                 @processor.rewrite(s(:major_rewrite, :a, :b)))
+  end
+
   def test_rewrite_deep
     assert_equal(s(:specific, s(:rewritable, :b, :a)),
                  @processor.rewrite(s(:specific, s(:rewritable, :a, :b))))
   end
 
-  def test_process_rewrite
-    assert_equal(s(:rewritable, true, true),
-                 @processor.process(s(:rewritable, 1, 2)))
+  def test_rewrite_not_empty
+    insert = s(:rewritable, 1, 2, 2)
+    expect = s(:rewritable, 2, 1)
+    result = @processor.rewrite(insert)
+    assert_equal(expect, result)
+    assert_equal(s(2), insert) # post-processing
   end
 
-  def test_process_rewrite_deep
-    assert_equal(s(s(:rewritable, :b, :a)),
-                 @processor.process(s(:specific, s(:rewritable, :a, :b))))
+  def test_process_rewrite
+    assert_equal(s(:rewritten, s(:y, 2), s(:x, 1), 0),
+                 @processor.process(s(:rewritable, s(:x, 1), s(:y, 2))))
   end
 
-  def test_process_rewrite_not_empty
-    assert_raise(NotEmptyError) do
-      @processor.process(s(:rewritable, 1, 2, 2))
-    end
+  def test_process_rewrite_deep
+    assert_equal(s(:blah, s(:rewritten, s(:b), s(:a), 0)),
+                 @processor.process(s(:specific, s(:rewritable, s(:a), s(:b)))))
+  end
+
+  def test_rewrite_depth_first
+    inn = s(:specific,
+            s(:rewritable,
+              s(:a),
+              s(:rewritable,
+                s(:rewritable, s(:b), s(:c)),
+                s(:d))))
+    out = s(:specific,
+            s(:rewritable,
+              s(:rewritable,
+                s(:d),
+                s(:rewritable, s(:c), s(:b))),
+              s(:a)))
+
+    assert_equal(out, @processor.rewrite(inn))
+  end
+
+  def test_process_rewrite_depth_first
+    inn = s(:specific,
+            s(:rewritable,
+              s(:a),
+              s(:rewritable,
+                s(:rewritable, s(:b), s(:c)),
+                s(:d))))
+    out = s(:blah,
+            s(:rewritten,
+              s(:rewritten,
+                s(:d),
+                s(:rewritten, s(:c), s(:b), 0), 1),
+              s(:a), 2))
+
+    assert_equal(out, @processor.process(inn))
   end
 
   def test_assert_type_hit

data/test/test_unified_ruby.rb

@@ -0,0 +1,229 @@
+#!/usr/local/bin/ruby
+
+$TESTING = true
+
+require 'test/unit' if $0 == __FILE__ unless defined? $ZENTEST and $ZENTEST
+require 'test/unit/testcase'
+require 'sexp'
+require 'sexp_processor'
+require 'unified_ruby'
+
+class TestUnifier < SexpProcessor
+  include UnifiedRuby
+end
+
+# TODO:
+#
+# 1) DONE [vf]call => call
+# 2) DONE defn scope block args -> defn args scope block
+# 3) DONE [bd]method/fbody => defn
+# 4) rescue cleanup
+# 5) defs x -> defn self.x # ON HOLD
+# 6) ? :block_arg into args list?
+
+class TestUnifiedRuby < Test::Unit::TestCase
+  def setup
+    @sp = TestUnifier.new
+    @sp.require_empty = false
+  end
+
+  def doit
+    assert_equal @expect, @sp.process(@insert)
+  end
+
+  def test_rewrite_bmethod
+    @insert = s(:bmethod,
+                s(:dasgn_curr, :x),
+                s(:call, s(:dvar, :x), :+, s(:array, s(:lit, 1))))
+    @expect = s(:scope,
+                s(:block,
+                  s(:args, :x),
+                  s(:call, s(:lvar, :x), :+, s(:array, s(:lit, 1)))))
+
+    doit
+  end
+
+  def test_rewrite_bmethod_noargs
+    @insert = s(:bmethod,
+                nil,
+                s(:call, s(:vcall, :x), :+, s(:array, s(:lit, 1))))
+    @expect = s(:scope,
+                s(:block,
+                  s(:args),
+                  s(:call, s(:call, nil, :x, s(:arglist)),
+                    :+, s(:array, s(:lit, 1)))))
+
+    doit
+  end
+
+  def test_rewrite_bmethod_splat
+    @insert = s(:bmethod,
+                s(:masgn, s(:dasgn_curr, :params)),
+                s(:lit, 42))
+    @expect = s(:scope,
+                s(:block,
+                  s(:args, :"*params"),
+                  s(:lit, 42)))
+
+    doit
+  end
+
+  def test_rewrite_defn
+    @insert = s(:defn, :x, s(:scope, s(:block, s(:args), s(:nil))))
+    @expect = s(:defn, :x, s(:args), s(:scope, s(:block, s(:nil))))
+
+    doit
+  end
+
+  def test_rewrite_defn_attr
+    @insert = s(:defn, :writer=, s(:attrset, :@writer))
+    @expect = s(:defn, :writer=, s(:args), s(:attrset, :@writer))
+
+    doit
+  end
+
+  def test_rewrite_defn_block_arg
+    @insert = s(:defn, :blah,
+                s(:scope,
+                  s(:block,
+                    s(:args, "*args".intern),
+                    s(:block_arg, :block),
+                    s(:block_pass,
+                      s(:lvar, :block),
+                      s(:fcall, :other, s(:splat, s(:lvar, :args)))))))
+    @expect = s(:defn, :blah,
+                s(:args, "*args".intern, s(:block_arg, :block)),
+                s(:scope,
+                  s(:block,
+                    s(:block_pass,
+                      s(:lvar, :block),
+                      s(:call, nil, :other,
+                        s(:arglist, s(:splat, s(:lvar, :args))))))))
+
+    doit
+  end
+
+  def test_rewrite_dmethod
+    @insert = s(:dmethod,
+                :a_method,
+                s(:scope,
+                  s(:block,
+                    s(:args, :x),
+                    s(:lit, 42))))
+    @expect = s(:scope,
+                s(:block,
+                  s(:args, :x),
+                  s(:lit, 42)))
+
+    doit
+  end
+
+  def test_rewrite_fbody
+    @insert = s(:fbody,
+                s(:scope,
+                  s(:block,
+                    s(:args, :x),
+                    s(:call, s(:lvar, :x), :+, s(:array, s(:lit, 1))))))
+    @expect = s(:scope,
+                s(:block,
+                  s(:args, :x),
+                  s(:call, s(:lvar, :x), :+, s(:array, s(:lit, 1)))))
+
+    doit
+  end
+
+  def test_rewrite_defn_bmethod_alias
+    @insert = s(:defn, :group,
+                s(:fbody,
+                  s(:bmethod,
+                    s(:masgn, s(:dasgn_curr, :params)),
+                    s(:block,
+                      s(:lit, 42)))))
+    @expect = s(:defn, :group,
+                s(:args, :"*params"),
+                s(:scope,
+                  s(:block, s(:lit, 42))))
+
+    doit
+  end
+
+  # TODO: think about flattening out to 1 resbody only
+  def test_rewrite_resbody
+    @insert = s(:resbody,
+                s(:array, s(:const, :SyntaxError)),
+                s(:block, s(:lasgn, :e1, s(:gvar, :$!)), s(:lit, 2)),
+                s(:resbody,
+                  s(:array, s(:const, :Exception)),
+                  s(:block, s(:lasgn, :e2, s(:gvar, :$!)), s(:lit, 3))))
+
+    @expect = s(:resbody,
+                s(:array, s(:const, :SyntaxError), s(:lasgn, :e1, s(:gvar, :$!))),
+                s(:block, s(:lit, 2)),
+                s(:resbody,
+                  s(:array, s(:const, :Exception), s(:lasgn, :e2, s(:gvar, :$!))),
+                  s(:block, s(:lit, 3))))
+
+    doit
+  end
+
+  def test_rewrite_resbody_empty
+    # begin require 'rubygems'; rescue LoadError; end
+    @insert = s(:begin,
+                s(:rescue,
+                  s(:fcall, :require, s(:array, s(:str, "rubygems"))),
+                  s(:resbody, s(:array, s(:const, :LoadError)))))
+    @expect = s(:begin,
+                s(:rescue,
+                  s(:call, nil, :require, s(:arglist, s(:str, "rubygems"))),
+                  s(:resbody, s(:array, s(:const, :LoadError)), nil)))
+
+    doit
+  end
+
+  def test_rewrite_resbody_lasgn
+    @insert = s(:resbody,
+                s(:array, s(:const, :SyntaxError)),
+                s(:lasgn, :e1, s(:gvar, :$!)),
+                s(:resbody,
+                  s(:array, s(:const, :Exception)),
+                  s(:block, s(:lasgn, :e2, s(:gvar, :$!)), s(:lit, 3))))
+
+    @expect = s(:resbody,
+                s(:array, s(:const, :SyntaxError), s(:lasgn, :e1, s(:gvar, :$!))),
+                nil,
+                s(:resbody,
+                  s(:array, s(:const, :Exception), s(:lasgn, :e2, s(:gvar, :$!))),
+                  s(:block, s(:lit, 3))))
+
+    doit
+  end
+
+  def test_rewrite_defn_ivar
+    @insert = s(:defn, :reader, s(:ivar, :@reader))
+    @expect = s(:defn, :reader, s(:args), s(:ivar, :@reader))
+
+    doit
+  end
+
+  def test_rewrite_vcall
+    @insert = s(:vcall, :puts)
+    @expect = s(:call, nil, :puts, s(:arglist))
+
+    doit
+  end
+
+  def test_rewrite_fcall
+    @insert = s(:fcall,     :puts, s(:array, s(:lit, :blah)))
+    @expect = s(:call, nil, :puts, s(:arglist, s(:lit, :blah)))
+
+    doit
+  end
+
+  def test_rewrite_fcall_loop
+    @insert = s(:iter, s(:fcall, :loop), nil)
+    @expect = s(:iter, s(:call, nil, :loop, s(:arglist)), nil)
+
+    doit
+  end
+
+end

metadata

@@ -3,16 +3,16 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.7.1
-date: 2007-06-05 00:00:00 -07:00
-summary: Extract and enumerate ruby parse trees.
+  version: 2.0.0
+date: 2007-08-01 00:00:00 -07:00
+summary: 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.
 require_paths: 
 - lib
 - test
 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.
+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.  As an example:  def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end  becomes:  [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]  * Uses RubyInline, so it just drops in. * Includes SexpProcessor and CompositeSexpProcessor. * Allows you to write very clean filters. * Includes UnifiedRuby, allowing you to automatically rewrite ruby quirks. * ParseTree#parse_tree_for_string lets you parse arbitrary strings of ruby. * Includes parse_tree_show, which lets you quickly snoop code. * echo \"1+1\" | parse_tree_show -f for quick snippet output. * Includes parse_tree_abc, which lets you get abc metrics on code. * abc metrics = numbers of assignments, branches, and calls. * whitespace independent metric for method complexity. * Includes parse_tree_deps, which shows you basic class level dependencies. * Does not work on the core classes, as they are not ruby (yet)."
 autorequire: 
 default_executable: 
 bindir: bin
@@ -43,6 +43,7 @@ files:
 - lib/parse_tree.rb
 - lib/sexp.rb
 - lib/sexp_processor.rb
+- lib/unified_ruby.rb
 - lib/unique.rb
 - test/pt_testcase.rb
 - test/something.rb
@@ -51,6 +52,7 @@ files:
 - test/test_parse_tree.rb
 - test/test_sexp.rb
 - test/test_sexp_processor.rb
+- test/test_unified_ruby.rb
 - validate.sh
 test_files: 
 - test/test_all.rb
@@ -78,7 +80,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.2.0
+        version: 3.6.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
@@ -87,5 +89,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.2.1
+        version: 1.2.2
     version: