ParseTree 2.1.1 → 2.2.0

data/test/test_parse_tree.rb

@@ -18,14 +18,24 @@ class SomethingWithInitialize
   def protected_meth; end
 end
 
+$verbose_methods = {
+  "test_begin_rescue_twice" => true,
+  "test_block_stmt_after" => true,
+  "test_block_stmt_both" => true,
+}
+
 class ParseTree
-  def process(input) # makes it play with with ParseTreeTestCase (FIX?)
+  def process(input, verbose = nil) # TODO: remove
+
+    test_method = caller[0][/\`(.*)\'/, 1]
+    verbose = $verbose_methods[test_method]
+
     # um. kinda stupid, but cleaner
     case input
     when Array then
       ParseTree.translate(*input)
     else
-      ParseTree.translate(input)
+      self.parse_tree_for_string(input, '(string)', 1, verbose).first
     end
   end
 end
@@ -77,7 +87,7 @@ class TestParseTree < ParseTreeTestCase
   def test_parse_tree_for_string_with_newlines
     @processor = ParseTree.new(true)
     actual   = @processor.parse_tree_for_string "1 +\n nil", 'test.rb', 5
-    expected = [[:newline, 6, "test.rb", 
+    expected = [[:newline, 6, "test.rb",
                  [:call, [:lit, 1], :+, [:array, [:nil]]]]]
 
     assert_equal expected, actual
@@ -171,7 +181,6 @@ class TestParseTree < ParseTreeTestCase
                 :unknown_args,
                 [:array, [:lit, 4], [:str, "known"]]]]]]]]
 
-
   @@attrasgn = [:defn,
     :attrasgn,
     [:scope,
@@ -188,7 +197,7 @@ class TestParseTree < ParseTreeTestCase
   Something.instance_methods(false).sort.each do |meth|
     if class_variables.include?("@@#{meth}") then
       @@__all << eval("@@#{meth}")
-      eval "def test_#{meth}; assert_equal @@#{meth}, @processor.parse_tree_for_method(Something, :#{meth}); end"
+      eval "def test_#{meth}; assert_equal @@#{meth}, @processor.parse_tree_for_method(Something, :#{meth}, false, false); end"
     else
       eval "def test_#{meth}; flunk \"You haven't added @@#{meth} yet\"; end"
     end
@@ -207,7 +216,7 @@ class TestParseTree < ParseTreeTestCase
   def test_missing
     assert_equal(@@missing,
                  @processor.parse_tree_for_method(Something, :missing),
-                 "Must return -3 for missing methods")
+                 "Must return #{@@missing.inspect} for missing methods")
   end
 
   def test_whole_class

data/test/test_sexp.rb

@@ -10,6 +10,12 @@ require 'pp'
 
 class SexpTestCase < Test::Unit::TestCase
 
+  unless defined? Mini then
+    alias :refute_nil :assert_not_nil
+    alias :refute_equal :assert_not_equal
+    alias :assert_raises :assert_raise
+  end
+
   # KEY for regex tests
   # :a == no change
   # :b == will change (but sometimes ONLY once)
@@ -19,12 +25,12 @@ class SexpTestCase < Test::Unit::TestCase
 
   def util_equals(x, y)
     result = x == y
-    assert_not_nil result, "#{x.inspect} does not === #{y.inspect}"
+    refute_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}"
+    refute_nil result, "#{x.inspect} does not === #{y.inspect}"
   end
 
   def setup
@@ -96,8 +102,8 @@ class TestSexp < SexpTestCase # ZenTest FULL
 
   def test_equals2_array
     # can't use assert_equals because it uses array as receiver
-    assert_not_equal(@sexp, [1, 2, 3],
-                     "Sexp must not be equal to equivalent array")
+    refute_equal(@sexp, [1, 2, 3],
+                 "Sexp must not be equal to equivalent array")
     # both directions just in case
     # HACK - this seems to be a bug in ruby as far as I'm concerned
     # assert_not_equal([1, 2, 3], @sexp,
@@ -106,24 +112,13 @@ class TestSexp < SexpTestCase # ZenTest FULL
 
   def test_equals2_not_body
     sexp2 = s(1, 2, 5)
-    assert_not_equal(@sexp, sexp2)
+    refute_equal(@sexp, sexp2)
   end
 
   def test_equals2_sexp
     sexp2 = s(1, 2, 3)
-    if @sexp.class == Sexp then
-#    sexp3 = t(1, 2, 3, Type.str)
-#    case @sexp
-#    when TypedSexp
-#      assert_equal(@sexp, sexp3)
-#      assert_not_equal(@sexp, sexp2)
-#    when Sexp
-      assert_equal(@sexp, sexp2)
-#      assert_not_equal(@sexp, sexp3)
-    else
-      assert_not_equal(@sexp, sexp2)
-#    else
-#      flunk "unknown type"
+    unless @sexp.class == Sexp then
+      refute_equal(@sexp, sexp2)
     end
   end
 
@@ -169,8 +164,8 @@ class TestSexp < SexpTestCase # ZenTest FULL
 #   end
 
   def test_equalstilde_fancy
-    assert_nil     s(:b) =~ s(:a, s(:b), :c)
-    assert_not_nil s(:a, s(:b), :c) =~ s(:b)
+    assert_nil s(:b) =~ s(:a, s(:b), :c)
+    refute_nil s(:a, s(:b), :c) =~ s(:b)
   end
 
   def test_equalstilde_plain
@@ -256,7 +251,7 @@ class TestSexp < SexpTestCase # ZenTest FULL
     assert_equal(2, @sexp.shift)
     assert_equal(3, @sexp.shift)
 
-    assert_raise(RuntimeError) do
+    assert_raises(RuntimeError) do
       @sexp.shift
     end
   end

data/test/test_sexp_processor.rb

@@ -123,7 +123,7 @@ class TestSexpProcessor < Test::Unit::TestCase
     @processor = TestProcessor.new
     @processor.warn_on_default = false
 
-    assert_raises(SexpTypeError) do
+    assert_raises SexpTypeError do
       @processor.process([:broken, 1, 2, 3])
     end
   end
@@ -132,7 +132,7 @@ class TestSexpProcessor < Test::Unit::TestCase
     @processor = TestProcessor.new
     @processor.unsupported << :strip
 
-    assert_raises(UnsupportedNodeError) do
+    assert_raises UnsupportedNodeError do
       @processor.process([:whatever])
     end
   end
@@ -140,14 +140,14 @@ class TestSexpProcessor < Test::Unit::TestCase
   def test_unsupported_equal
     @processor.strict = true
     @processor.unsupported = [ :unsupported ]
-    assert_raises(UnsupportedNodeError) do
+    assert_raises UnsupportedNodeError do
       @processor.process([:unsupported, 42])
     end
   end
 
   def test_strict
     @processor.strict = true
-    assert_raise(UnknownNodeError) do
+    assert_raises UnknownNodeError do
       @processor.process([:blah, 1, 2, 3])
     end
   end
@@ -156,13 +156,11 @@ class TestSexpProcessor < Test::Unit::TestCase
   def test_require_empty_false
     @processor.require_empty = false
 
-    assert_nothing_raised do
-      @processor.process([:nonempty, 1, 2, 3])
-    end
+    @processor.process([:nonempty, 1, 2, 3])
   end
 
   def test_require_empty_true
-    assert_raise(NotEmptyError) do
+    assert_raises NotEmptyError do
       @processor.process([:nonempty, 1, 2, 3])
     end
   end
@@ -241,13 +239,11 @@ class TestSexpProcessor < Test::Unit::TestCase
   end
 
   def test_assert_type_hit
-    assert_nothing_raised do
-      @processor.assert_type([:blah, 1, 2, 3], :blah)
-    end
+    @processor.assert_type([:blah, 1, 2, 3], :blah)
   end
 
   def test_assert_type_miss
-    assert_raise(SexpTypeError) do
+    assert_raises SexpTypeError do
       @processor.assert_type([:thingy, 1, 2, 3], :blah)
     end
   end
@@ -274,7 +270,7 @@ class TestSexpProcessor < Test::Unit::TestCase
 
   def test_expected
     assert_equal Sexp, @processor.expected
-    assert_raises(SexpTypeError) do
+    assert_raises SexpTypeError do
       @processor.process([:expected])           # should raise
     end
 
@@ -284,7 +280,7 @@ class TestSexpProcessor < Test::Unit::TestCase
     assert_equal Hash, @processor.expected
     assert !(Hash === s()), "Hash === s() should not be true"
 
-    assert_raises(SexpTypeError) do
+    assert_raises SexpTypeError do
       @processor.process(s(:string, "string"))     # should raise
     end
 

data/test/test_unified_ruby.rb

@@ -31,17 +31,6 @@ class TestUnifiedRuby < Test::Unit::TestCase
     assert_equal @expect, @sp.process(@insert)
   end
 
-  def test_argscat
-    @insert = s(:argscat,
-                s(:array, s(:lvar, :container), s(:lvar, :point)),
-                s(:lvar, :args))
-    @expect = s(:argscat,
-                s(:arglist, s(:lvar, :container), s(:lvar, :point)),
-                s(:lvar, :args))
-
-    doit
-  end
-
   def test_call_args
     @insert = s(:call, s(:lit, 42), :y, s(:array, s(:lit, 24)))
     @expect = s(:call, s(:lit, 42), :y, s(:arglist, s(:lit, 24)))
@@ -75,6 +64,15 @@ class TestUnifiedRuby < Test::Unit::TestCase
     doit
   end
 
+  # [:proc, [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]]]]
+
+  # proc { |x,y| x + y }
+  # =
+  # s(:iter,
+  #  s(:fcall, :proc),
+  #  s(:masgn, s(:array, s(:dasgn_curr, :x), s(:dasgn_curr, :y))),
+  #  s(:call, s(:dvar, :x), :+, s(:array, s(:dvar, :y))))
+
   def test_rewrite_bmethod_noargs
     @insert = s(:bmethod,
                 nil,
@@ -179,20 +177,6 @@ class TestUnifiedRuby < Test::Unit::TestCase
     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(:arglist, s(:lit, 1)))))
-
-    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)))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2007-12-22 00:00:00 -08:00
+date: 2008-06-09 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,10 +28,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.4.0
+        version: 1.5.3
     version: 
-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)."
-email: ryand-ruby@zenspider.com
+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]]]]]"
+email: 
+- ryand-ruby@zenspider.com
 executables: 
 - parse_tree_abc
 - parse_tree_audit
@@ -69,7 +70,7 @@ files:
 - test/test_unified_ruby.rb
 - validate.sh
 has_rdoc: true
-homepage: http://www.zenspider.com/ZSS/Products/ParseTree/
+homepage: http://rubyforge.org/projects/parsetree/
 post_install_message: 
 rdoc_options: 
 - --main
@@ -92,9 +93,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: parsetree
-rubygems_version: 1.0.1
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
-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.
+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
 test_files: 
 - test/test_all.rb