jruby-parser 0.3 → 0.4

data/lib/jruby-parser/version.rb

@@ -1,3 +1,3 @@
 module JRubyParser
-  VERSION = "0.3"
+  VERSION = "0.4"
 end

data/spec/helpers/node_helpers.rb

@@ -110,11 +110,123 @@ module HaveArgCounts
     ArgCountsMatcher.new(*args)
   end
 end
- 
+
+class HaveParametersMatcher
+  def initialize(*list)
+    @with_decorations = []
+    @without_decorations = []
+    list.each do |e1, e2|
+      @without_decorations << e1
+      @with_decorations << (e2 || e1)
+    end
+  end
+
+  def matches?(args)
+    @actual_with = args.get_normative_parameter_name_list(false).to_a
+    @actual_without = args.get_normative_parameter_name_list(true).to_a
+    @with_decorations == @actual_with && @without_decorations == @actual_without
+  end
+
+  def failure_message
+    error = ""
+    if @with_decorations != @actual_with
+      error << %[expected #{@actual_with.inspect} to have #{@with_decorations.inspect}.]
+    end
+
+    if @without_decorations != @actual_without
+      error << %[ expected #{@actual_without.inspect} to have #{@without_decorations.inspect}.]
+    end
+    error
+  end
+
+  def negative_failure_message
+    error = ""
+    if @with_decorations != @actual_with
+      error << %[expected #{@actual_with.inspect} to not have #{@with_decorations.inspect}.]
+    end
+
+    if @without_decorations != @actual_without
+      error << %[ expected #{@actual_without.inspect} to not have #{@without_decorations.inspect}.]
+    end
+    error
+  end
+end
+
+module HaveParameters
+  def have_parameters(*args)
+    HaveParametersMatcher.new(*args)
+  end
+end
+
+class HaveStaticAssignmentsMatcher
+  java_import org.jrubyparser.ast.FixnumNode
+  java_import org.jrubyparser.ast.ListNode
+
+  def initialize(list)
+    @list = list
+  end
+
+  def matches?(args)
+    @actual_list = args.calculateStaticAssignments.to_a
+    @failures_var_names = []
+    @failures_var_values = []
+    
+    @list.each_with_index do |arr, i|
+      node_pair = @actual_list[i]
+      expected_var, expected_value = arr[0].to_s, arr[1]
+      actual_var, actual_value = node_pair.first.name, value_for(node_pair.second)
+      
+      @failures_var_names << [expected_var, actual_var] if expected_var != actual_var
+      @failures_var_values << [expected_value, actual_value] if expected_value != actual_value
+      
+    end
+    
+    @failures_var_names.size == 0 && @failures_var_values.size == 0
+  end
+
+   def value_for(node)
+    if node.kind_of? FixnumNode
+      node.value
+    elsif node.kind_of? ListNode
+      node.child_nodes.map {|e| value_for(e)}
+    else
+      node
+    end
+  end
+
+  def failure_message
+    names = @failures_var_names.inject("names: ") do |s, e|
+      s << "#{e[0]} != #{e[1]} "
+    end
+
+    @failures_var_values.inject(names + "\nvalues: ") do |s, e|
+      s << "#{e[0]} != #{e[1]} "
+    end
+  end
+
+  def negative_failure_message
+    names = @failures_var_names.inject("names: ") do |s, e|
+      s << "#{e[0]} !!= #{e[1]}"
+    end
+
+    @failures_var_values.inject(names + "\nvalues: ") do |s, e|
+      s << "#{e[0]} !!= #{e[1]} "
+    end
+  end
+end
+
+module HaveStaticAssignments
+  def have_static_assignments(*args)
+    HaveStaticAssignmentsMatcher.new(*args)
+  end
+end
+
 #module Spec::Example::ExampleMethods
 class Object
   include HavePosition
   include HaveName
   include HaveNameAndPosition
   include HaveArgCounts
+  include HaveParameters
+  include HaveStaticAssignments
 end

data/spec/helpers/parser_helpers.rb

@@ -20,4 +20,17 @@ class Object
     config = version == 1.8  ? CONFIG_18 : CONFIG_19
     PARSER.parse "<code>", source(code), config
   end
+
+  ##
+  # parse code but record first '^' and return the node which 
+  # that offset represents.  If you are testing source which contains
+  # a caret already you can substitute the value with a delimeter which
+  # will work.
+  def caret_parse(code, version=1.8, caret='^')
+    caret_index = code.index(caret)
+    raise ArgumentError.new("Caret '^' missing: #{code}") unless caret_index
+
+    root = parse(code.sub(caret, ''), version)
+    [root, root.node_at(caret_index)]
+  end
 end

data/spec/jruby-parser/find_scopes_spec.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
+require 'java'
+require 'jruby-parser'
+require 'parser_helpers'
+
+describe JRubyParser do
+  [JRubyParser::Compat::RUBY1_8, JRubyParser::Compat::RUBY1_9].each do |v|
+    it "children can ask for the method it is contained in [#{v}]" do
+      parse("def foo; true if false; end").find_node(:defn) do |defn|
+        defn.find_node(:true).method_for.should == defn
+        defn.find_node(:false).method_for.should == defn
+        defn.find_node(:if).method_for.should == defn
+      end
+    end
+
+    it "children can ask for the iter/block it is contained in [#{v}]" do
+      parse("proc { |a| proc { |b| true } }").find_node(:iter) do |iter1|
+        iter1.find_node(:true).innermost_iter.should_not == iter1
+        iter1.find_node(:true).outermost_iter.should == iter1
+      end
+    end
+
+    it "should not find an innermost block if method is inside block" do
+      parse("proc { def foo; true; end }").find_node(:true) do |tru|
+        tru.innermost_iter.should == nil
+        tru.outermost_iter.should == nil
+      end
+    end
+  end
+end

data/spec/jruby-parser/find_spec.rb

@@ -1,25 +1,27 @@
 $LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
 require 'java'
 require 'jruby-parser'
+require 'parser_helpers'
 
 describe JRubyParser do
-  [JRubyParser::Compat::RUBY1_8, JRubyParser::Compat::RUBY1_9].each do |v|
-    it "finds fcall via simple symbol search" do
-      JRubyParser.parse("b = foo(1)").tap do |root|
+  [1.8, 1.9].each do |v|
+    it "finds fcall via simple symbol search [#{v}]" do
+      parse("b = foo(1)").tap do |root|
         fcall = root.find_type(:fcall)
         fcall.should_not == nil
       end
     end
 
-    it "finds specific fcall by block and simple symbol" do
-      JRubyParser.parse("foo(1); bar(2)").tap do |root|
+    it "finds specific fcall by block and simple symbol [#{v}]" do
+      parse("foo(1); bar(2)").tap do |root|
         fcall = root.find_type(:fcall) { |n| n.name == "bar" }
         fcall.name.should == "bar"
       end
     end
 
-    it "finds type and method named based on Enumerable find" do
-      JRubyParser.parse("foo(1); bar(2)").tap do |root|
+    it "finds type and method named based on Enumerable find [#{v}]" do
+      parse("foo(1); bar(2)").tap do |root|
         fcall = root.find { |n| n.short_name == "fcall" && n.name == "bar"}
         fcall.name.should == "bar"
         fcalls = root.find_all { |n| n.short_name == "fcall" }

data/spec/jruby-parser/get_node_at_spec.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
+require 'java'
+require 'jruby-parser'
+require 'parser_helpers'
+
+describe JRubyParser do
+  [1.8, 1.9].each do |v|
+    it "finds fcall via simple getNodeAt search [#{v}]" do
+      caret_parse("b = fo^o(1)", v).tap do |root, caret_node|
+        root.find_node(:fcall).should == caret_node
+      end
+      caret_parse("b = foo(^1)", v).tap do |root, caret_node|
+        root.find_node(:fixnum).should == caret_node
+      end
+    end
+  end
+end

data/spec/jruby-parser/is_block_parameter_spec.rb

@@ -0,0 +1,38 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
+require 'java'
+require 'jruby-parser'
+require 'parser_helpers'
+
+describe JRubyParser do
+  [1.8, 1.9].each do |v|
+    it "finds parameter via is_block_parameter [#{v}]" do
+      caret_parse("proc { |^a| }", v).tap do |root, caret_node|
+        caret_node.block_parameter?.should == true
+      end
+      caret_parse("proc { |^a,b| }", v).tap do |root, caret_node|
+        caret_node.block_parameter?.should == true
+      end
+      caret_parse("proc { |*^a| }", v).tap do |root, caret_node|
+        caret_node.block_parameter?.should == true
+      end
+      caret_parse("proc { |a, (b, ^c)| }", v).tap do |root, caret_node|
+        caret_node.block_parameter?.should == true
+      end
+      caret_parse("proc { |&^a| }", v).tap do |root, caret_node|
+        caret_node.block_parameter?.should == true
+      end
+
+      if v == 1.9
+        caret_parse("proc { |a, ^b=1| }", v).tap do |root, caret_node|
+          caret_node.block_parameter?.should == true
+        end
+
+        caret_parse("proc { |c| proc { |a, b=^c| } }", v).tap do |root, caret_node|
+          caret_node.block_parameter?.should == false
+        end
+
+      end
+    end
+  end
+end

data/spec/jruby-parser/is_method_parameter_spec.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
+require 'java'
+require 'jruby-parser'
+require 'parser_helpers'
+
+describe JRubyParser do
+  [1.8, 1.9].each do |v|
+    it "finds  parameter via is_method_parameter [#{v}]" do
+      caret_parse("def foo(^a); end", v).tap do |root, caret_node|
+        caret_node.method_parameter?.should == true
+      end
+      caret_parse("def foo(^a,b); end", v).tap do |root, caret_node|
+        caret_node.method_parameter?.should == true
+      end
+      caret_parse("def foo(*^a); end", v).tap do |root, caret_node|
+        caret_node.method_parameter?.should == true
+      end
+      caret_parse("def foo(&^a); end", v).tap do |root, caret_node|
+        caret_node.method_parameter?.should == true
+      end
+      caret_parse("def foo(a, ^b=1); end", v).tap do |root, caret_node|
+        caret_node.method_parameter?.should == true
+      end
+      if v == 1.9
+        caret_parse("def foo(a, (b, ^c)); end", v).tap do |root, caret_node|
+          caret_node.method_parameter?.should == true
+        end
+        caret_parse("def foo(a, b=1, ^c); end", v).tap do |root, caret_node|
+          caret_node.method_parameter?.should == true
+        end
+      end
+    end
+  end
+end

data/spec/jruby-parser/rewriting_spec.rb

@@ -2,51 +2,51 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
 require 'jruby-parser'
 
 describe JRubyParser do
-  [JRubyParser::Compat::RUBY1_8, JRubyParser::Compat::RUBY1_9].each do |v|
-    it "rewrites method name from foo to bar" do
-      JRubyParser.parse("b = foo(1)").tap do |root|
+  [1.8, 1.9].each do |v|
+    it "rewrites method name from foo to bar [#{v}]" do
+      parse("b = foo(1)").tap do |root|
         fcall = root.find_node(:fcall)
         fcall.name = 'bar'
       end.to_source.should == "b = bar(1)"
 
-      JRubyParser.parse("b = foo 1").tap do |root|
+      parse("b = foo 1").tap do |root|
         fcall = root.find_node(:fcall)
         fcall.name = 'bar'
       end.to_source.should == "b = bar 1"
     end
 
-    it "rewrites between different coercible ruby types" do
+    it "rewrites between different coercible ruby types [#{v}]" do
       [1, 1.0, true, false, nil, "a"].each do |replace|
-        JRubyParser.parse("foo 1").tap do |root|
+        parse("foo 1").tap do |root|
           fcall = root.find_node(:fcall)
           fcall.args[0] = replace
         end.to_source.should == "foo #{replace.inspect}"
       end
     end
 
-    it "rewrites receiver of a call" do
-      JRubyParser.parse("1.to_f(1)").tap do |root|
+    it "rewrites receiver of a call [#{v}]" do
+      parse("1.to_f(1)").tap do |root|
         call = root.find_node(:call)
         call.receiver = 2
       end.to_source.should == "2.to_f(1)"
     end
 
-    it "rewrites can add to simple args" do
-      JRubyParser.parse("foo(1)").tap do |root|
+    it "rewrites can add to simple args [#{v}]" do
+      parse("foo(1)").tap do |root|
         call = root.find_node(:fcall)
         call.args << 2
       end.to_source.should == "foo(1, 2)"
     end
 
-    it "rewrites can add to simple args" do
-      JRubyParser.parse("foo(1)").tap do |root|
+    it "rewrites can add to simple args [#{v}]" do
+      parse("foo(1)").tap do |root|
         call = root.find_node(:fcall)
         call.args = [3, 4]
       end.to_source.should == "foo(3, 4)"
     end
 
-    it "rewrites op element assignment" do
-      JRubyParser.parse("a[3] += 5").tap do |root|
+    it "rewrites op element assignment [#{v}]" do
+      parse("a[3] += 5").tap do |root|
         op = root.find_node(:opelementasgn)
         op.receiver = 1
         op.args[0] = 2

data/spec/jruby-parser/static_analysis_spec.rb

@@ -0,0 +1,171 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+require 'jruby-parser'
+require 'parser_helpers'
+require 'node_helpers'
+
+describe Parser do
+  [1.9].each do |v|
+    it "parses a simple multiple assignment [#{v}]" do
+      parse("a,b,c = 1,2,3", v).find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, 1], [:b, 2], [:c, 3]])
+      end
+    end
+
+    it "parses a simple lhs splat multiple assignment [#{v}]" do
+      parse("a,*b = 1,2,3", v).find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, 1], [:b, [2, 3]]])
+      end
+      parse("a,b,*c = 1,2,3,4", v).find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, 1], [:b, 2], [:c, [3,4]]])
+      end
+    end
+
+    it "parses a simple lhs splat multiple assignment [#{v}]" do
+      parse("*a,b = 1,2,3", v).find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, [1, 2]], [:b, 3]])
+      end
+      parse("*a,b,c = 1,2,3,4", v).find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, [1, 2]], [:b, 3], [:c, 4]])
+      end
+    end
+
+    it "parses a simple lhs splat multiple assignment [#{v}]" do
+      parse("a,*b, c = 1,2,3,4", v).find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, 1], [:b, [2, 3]], [:c, 4]])
+      end
+      parse("a, b, *c, d = 1,2,3,4,5", v).find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, 1], [:b, 2], [:c, [3, 4]], [:d, 5]])
+      end
+      parse("a, *b, c, d = 1,2,3,4,5", v).find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, 1], [:b, [2, 3]], [:c, 4], [:d, 5]])
+      end
+    end
+
+    it "parses a simple lhs splat multiple assignment [#{v}]" do
+      parse("a,*b,c,d = 1,2,3", v).find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, 1], [:b, []], [:c, 2], [:d, 3]])
+      end
+    end
+
+    it "parses a simple rhs splat multiple assignment [#{v}]" do
+      ast = parse("a,*b = 1,*foo", v)
+      foo = ast.find_node(:vcall)
+      ast.find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, 1], [:b, foo]])
+      end
+    end
+
+    it "parses a simple rhs splat multiple assignment [#{v}]" do
+      ast = parse("*a,b = *foo,1", v)
+      splatted_foo = ast.find_node(:splat)
+      ast.find_node(:multipleasgn19).tap do |masgn|
+        masgn.should have_static_assignments([[:a, splatted_foo], [:b, 1]])
+      end
+    end
+
+    it "method: Can detect simple parameter is used" do
+      parse("def foo(a); a; end").find_node(:defn) do |defn|
+        defn.args.get_normative_parameter_name_list(true).each do |parameter|
+          defn.is_parameter_used(parameter).should == true
+        end
+      end
+
+      parse("def foo(a,b); a; b; end").find_node(:defn) do |defn|
+        defn.args.get_normative_parameter_name_list(true).each do |parameter|
+          defn.is_parameter_used(parameter).should == true
+        end
+      end
+
+      parse("def foo(a,b); a=1; b; end").find_node(:defn) do |defn|
+        defn.is_parameter_used("a").should == false
+        defn.is_parameter_used("b").should == true
+      end
+    end
+
+    it "method: Can detect some simple parameters are used" do
+      parse("def foo(a,b); b; end").find_node(:defn) do |defn|
+        defn.is_parameter_used("a").should == false
+        defn.is_parameter_used("b").should == true
+      end
+
+      parse("def foo(a,b); b if true; end").find_node(:defn) do |defn|
+        defn.is_parameter_used("a").should == false
+        defn.is_parameter_used("b").should == true
+      end
+
+      parse("def foo(a,b); proc { b if true }; end").find_node(:defn) do |defn|
+        defn.is_parameter_used("a").should == false
+        defn.is_parameter_used("b").should == true
+      end
+
+      parse("def foo a, b, c\nputs a, b, c\nend").find_node(:defn) do |defn|
+        defn.is_parameter_used("a").should == true
+        defn.is_parameter_used("b").should == true
+        defn.is_parameter_used("c").should == true
+      end
+
+      parse("def foo(a, b); b.each_answer {|n| data if n == a }; end") do |defn|
+        defn.is_parameter_used("a").should == true
+        defn.is_parameter_used("b").should == true
+      end
+    end
+
+    it "method: Can detect some simple optarg params are used" do
+      parse("def foo(a,b = {}); b; end").find_node(:defn) do |defn|
+        defn.is_parameter_used("a").should == false
+        defn.is_parameter_used("b").should == true
+      end
+    end
+
+    it "method: Can detect zsuper usage" do
+      parse("def foo(a,b = {}); super; end").find_node(:defn) do |defn|
+        defn.is_parameter_used("a").should == true
+        defn.is_parameter_used("b").should == true
+      end
+    end
+
+    it "block/iter: Can detect simple parameter is used" do
+      parse("proc { |a, b| a; b }").find_node(:iter) do |iter|
+        iter.is_parameter_used("a").should == true
+        iter.is_parameter_used("b").should == true
+      end
+    end
+
+    it "block/iter: Can detect simple parameter is used" do
+      parse("proc { |a, b| a=1; b }").find_node(:iter) do |iter|
+        iter.is_parameter_used("a").should == false
+        iter.is_parameter_used("b").should == true
+      end
+    end
+
+    it "block/iter: Can detect some simple parameters are used" do
+      parse("proc {|a,b| b }").find_node(:iter) do |iter|
+        iter.is_parameter_used("a").should == false
+        iter.is_parameter_used("b").should == true
+      end
+
+      parse("proc {|a,b| b if true }").find_node(:iter) do |iter|
+        iter.is_parameter_used("a").should == false
+        iter.is_parameter_used("b").should == true
+      end
+
+      parse("proc {|a,b| proc { b if true } }").find_node(:iter) do |iter|
+        iter.is_parameter_used("a").should == false
+        iter.is_parameter_used("b").should == true
+      end
+
+      parse("proc {|a, b, c| puts a, b, c }").find_node(:iter) do |iter|
+        iter.is_parameter_used("a").should == true
+        iter.is_parameter_used("b").should == true
+        iter.is_parameter_used("c").should == true
+      end
+
+      parse("proc {|a, b| b.each_answer {|n| data if n == a } }") do |iter|
+        iter.is_parameter_used("a").should == true
+        iter.is_parameter_used("b").should == true
+      end
+    end
+
+  end
+end

data/spec/positions/arg_spec.rb

@@ -10,6 +10,7 @@ describe Parser do
       parse("def foo\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 11)
         defn.args_node.should have_arg_counts(0, 0, false, false)
+        defn.args_node.should have_parameters()
       end
     end
 
@@ -17,6 +18,7 @@ describe Parser do
       parse("def foo()\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 13)
         defn.args_node.should have_arg_counts(0, 0, false, false)
+        defn.args_node.should have_parameters()
       end
     end
 
@@ -24,6 +26,7 @@ describe Parser do
       parse("def foo a\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 13)
         defn.args_node.should have_arg_counts(1, 0, false, false)
+        defn.args_node.should have_parameters('a')
         defn.args_node.pre.tap do |pre|
           pre.should have_position(0, 0, 8, 9)
           pre[0].should have_name_and_position("a", 0, 0, 8, 9)
@@ -35,6 +38,7 @@ describe Parser do
       parse("def foo(a)\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 14)
         defn.args_node.should have_arg_counts(1, 0, false, false)
+        defn.args_node.should have_parameters('a')
         defn.args_node.pre.tap do |pre|
           pre.should have_position(0, 0, 8, 9)
           pre[0].should have_name_and_position("a", 0, 0, 8, 9)
@@ -46,6 +50,7 @@ describe Parser do
       parse("def foo a, b\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 16)
         defn.args_node.should have_arg_counts(2, 0, false, false)
+        defn.args_node.should have_parameters('a', 'b')
         defn.args_node.pre.tap do |pre|
           pre.should have_position(0, 0, 8, 12)
           pre[0].should have_name_and_position("a", 0, 0, 8, 9)
@@ -58,6 +63,7 @@ describe Parser do
       parse("def foo(a, b)\nend\n", v).find_node(:defn) do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 17)
         defn.args_node.should have_arg_counts(2, 0, false, false)
+        defn.args_node.should have_parameters('a', 'b')
         defn.args_node.pre.tap do |pre|
           pre.should have_position(0, 0, 8, 12)
           pre[0].should have_name_and_position("a", 0, 0, 8, 9)
@@ -70,6 +76,7 @@ describe Parser do
       parse("def foo a=1\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 15)
         defn.args_node.should have_arg_counts(0, 1, false, false)
+        defn.args_node.should have_parameters('a')
         lasgn = defn.args_node.optional.find_node(:localasgn)
         lasgn.should have_name_and_position("a", 0, 0, 8, 11)
       end
@@ -79,6 +86,7 @@ describe Parser do
       parse("def foo(a=1)\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 16)
         defn.args_node.should have_arg_counts(0, 1, false, false)
+        defn.args_node.should have_parameters('a')
         lasgn = defn.args_node.optional.find_node(:localasgn)
         lasgn.should have_name_and_position("a", 0, 0, 8, 11)
       end
@@ -88,6 +96,7 @@ describe Parser do
       parse("def foo *a\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 14)
         defn.args_node.should have_arg_counts(0, 0, true, false)
+        defn.args_node.should have_parameters(['a', '*a'])
       end
     end
 
@@ -95,6 +104,8 @@ describe Parser do
       parse("def foo(*a)\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 15)
         defn.args_node.should have_arg_counts(0, 0, true, false)
+        defn.args_node.rest.should have_position(0, 0, 8, 10)
+        defn.args_node.should have_parameters(['a', '*a'])
       end
     end
 
@@ -102,6 +113,7 @@ describe Parser do
       parse("def foo &a\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 14)
         defn.args_node.should have_arg_counts(0, 0, false, true)
+        defn.args_node.should have_parameters(['a', '&a'])
       end
     end
 
@@ -109,13 +121,17 @@ describe Parser do
       parse("def foo(&a)\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 15)
         defn.args_node.should have_arg_counts(0, 0, false, true)
+        defn.args_node.block.should have_position(0, 0, 8, 10)
+        defn.args_node.should have_parameters(['a', '&a'])
       end
     end
 
     it "parses a mixed-arg method sans parens [#{v}]" do
       parse("def foo a, b, c = 1, *d\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 27)
-        defn.args_node.should have_arg_counts(2, 1, true, false)
+        args = defn.args_node
+        args.should have_arg_counts(2, 1, true, false)
+        defn.args_node.should have_parameters('a', 'b', 'c', ['d', '*d'])
       end
     end
 
@@ -123,6 +139,7 @@ describe Parser do
       parse("def foo(a, b, c = 1, *d)\nend\n", v).find_node(:defn).tap do |defn|
         defn.should have_name_and_position("foo", 0, 1, 0, 28)
         defn.args_node.should have_arg_counts(2, 1, true, false)
+        defn.args_node.should have_parameters('a', 'b', 'c', ['d', '*d'])
       end
     end
   end

data/spec/positions/attr_asgn_spec.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+require 'jruby-parser'
+require 'parser_helpers'
+require 'node_helpers'
+
+describe Parser do
+  [1.8, 1.9].each do |v|
+    it "Should parse attr assign" do
+      parse("a[1] = 2", v).find_node(:attrassign).tap do |asgn|
+        asgn.should_not == nil
+      end
+    end
+  end
+end

data/spec/positions/call_spec.rb

@@ -6,6 +6,12 @@ require 'node_helpers'
 
 describe Parser do
   [1.8, 1.9].each do |v|
+    it "parses a 0-arg method call sans parens +extra line [#{v}]" do
+      parse("\nblock_given?\n", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("block_given?", 1, 1, 1, 13)
+      end
+    end
+
     it "parses a 0-arg method call sans parens +extra line [#{v}]" do
       parse("\nputs\n", v).find_node(:vcall).tap do |call|
         call.should have_name_and_position("puts", 1, 1, 1, 5)

metadata

@@ -1,33 +1,22 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: jruby-parser
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  version: "0.3"
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: '0.4'
 platform: ruby
-authors: 
+authors:
 - Thomas E. Enebo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2012-04-18 00:00:00 -05:00
-default_executable: 
+date: 2013-03-27 00:00:00.000000000 Z
 dependencies: []
-
 description: A Gem for syntactically correct parse trees of Ruby source
 email: tom.enebo@gmail.com
-executables: 
-- generate_parser
-- optimize_parser.rb
-- patch_parser.rb
+executables: []
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/jruby-parser.rb
 - lib/jruby-parser/core_ext/array.rb
 - lib/jruby-parser/core_ext/attr_assign_node.rb
@@ -48,56 +37,64 @@ files:
 - spec/ast/node_path.rb
 - spec/helpers/node_helpers.rb
 - spec/helpers/parser_helpers.rb
+- spec/jruby-parser/find_scopes_spec.rb
 - spec/jruby-parser/find_spec.rb
+- spec/jruby-parser/get_node_at_spec.rb
+- spec/jruby-parser/is_block_parameter_spec.rb
+- spec/jruby-parser/is_method_parameter_spec.rb
 - spec/jruby-parser/rewriting_spec.rb
+- spec/jruby-parser/static_analysis_spec.rb
 - spec/parser/alias_spec.rb
 - spec/parser/broken_spec.rb
 - spec/positions/arg_spec.rb
+- spec/positions/attr_asgn_spec.rb
 - spec/positions/call_spec.rb
 - spec/positions/conditionals_spec.rb
 - spec/positions/hash_spec.rb
 - spec/positions/heredoc_spec.rb
 - spec/positions/str_spec.rb
 - lib/jruby-parser.jar
-has_rdoc: true
 homepage: http://github.com/jruby/jruby-parser
 licenses: []
-
-post_install_message: 
+post_install_message:
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
 requirements: []
-
 rubyforge_project: jruby-parser
-rubygems_version: 1.3.6
-signing_key: 
+rubygems_version: 1.8.24
+signing_key:
 specification_version: 3
 summary: A Gem for syntactically correct parse trees of Ruby source
-test_files: 
+test_files:
 - spec/ast/node_path.rb
 - spec/helpers/node_helpers.rb
 - spec/helpers/parser_helpers.rb
+- spec/jruby-parser/find_scopes_spec.rb
 - spec/jruby-parser/find_spec.rb
+- spec/jruby-parser/get_node_at_spec.rb
+- spec/jruby-parser/is_block_parameter_spec.rb
+- spec/jruby-parser/is_method_parameter_spec.rb
 - spec/jruby-parser/rewriting_spec.rb
+- spec/jruby-parser/static_analysis_spec.rb
 - spec/parser/alias_spec.rb
 - spec/parser/broken_spec.rb
 - spec/positions/arg_spec.rb
+- spec/positions/attr_asgn_spec.rb
 - spec/positions/call_spec.rb
 - spec/positions/conditionals_spec.rb
 - spec/positions/hash_spec.rb

data/bin/generate_parser

@@ -1,46 +0,0 @@
-#!/bin/sh
-
-# Run from your JRuby home directory....More smarts needed here.
-
-###### Change these to tastes ######
-JAY=jay
-RUBY=ruby
-PARSER_BASE=DefaultRubyParser
-YYTABLE_PREFIX=
-DEBUG=true
-###### Do not change below ######
-
-if [ "$1" != "" ]; then
-  PARSER_BASE=$1
-fi
-shift
-
-if [ "$1" != "" ]; then
-  YYTABLE_PREFIX=$1
-fi
-
-if [ "$DEBUG" != "" ]; then
-  DEBUG_FLAG=-t
-  # Nonesense...my script-fu is weak
-  DEBUG_STRIP="xdyhbk"
-else
-  DEBUG_FLAG=
-  DEBUG_STRIP="^//t"
-fi
-
-echo "Generating Parser '$PARSER_BASE' w/ YYTable prefix of '$YYTABLE_PREFIX'"
-
-PARSER_DIR=src/org/jrubyparser/parser
-
-pushd $PARSER_DIR
-
-# Generate grammar as intermediate file
-$JAY $DEBUG_FLAG $PARSER_BASE.y < skeleton.parser | grep -v $DEBUG_STRIP >$PARSER_BASE.out
-
-# Patch file to get around Java static initialization issues plus extract
-# a bunch of stuff to seperate file (yytables).
-$RUBY ../../../../bin/patch_parser.rb $PARSER_BASE.out $YYTABLE_PREFIX > $PARSER_BASE.out2
-$RUBY ../../../../bin/optimize_parser.rb $PARSER_BASE.out2 $YYTABLE_PREFIX > $PARSER_BASE.java
-rm -f $PARSER_BASE.out $PARSER_BASE.out2
-
-popd

data/bin/optimize_parser.rb

@@ -1,106 +0,0 @@
-class PostProcessor
-  def initialize(source, out=STDOUT)
-    @out = out
-    @lines = File.readlines(source)
-    @index = -1
-    @case_bodies = {}
-    @max_case_number = -1
-  end
-
-  # Read/Unread with ability to push back one line for a single lookahead
-  def read
-    @index += 1
-    line = @last ? @last : @lines[@index]
-    @last = nil
-    line
-  end
-
-  def unread(line)
-    @index -= 1
-    @last = line
-  end
-
-  def end_of_actions?(line)
-     return line =~ %r{^//\s*ACTIONS_END}
-  end
-
-  def translate
-    while (line = read)
-      if line =~ %r{^//\s*ACTIONS_BEGIN}
-        translate_actions
-      elsif line =~ %r{^//\s*ACTION_BODIES}
-        generate_action_body_methods
-      else
-        @out.puts line
-      end
-    end
-  end
-
-  def generate_action_body_methods
-    @out.puts "static ParserState[] states = new ParserState[#{@max_case_number+1}];"
-    @out.puts "static {";
-    @case_bodies.each do |state, code_body| 
-      generate_action_body_method(state, code_body) 
-    end
-    @out.puts "}";
-  end
-
-  def generate_action_body_method(state, code_body)
-    @out.puts "states[#{state}] = new ParserState() {"
-    @out.puts "  public Object execute(ParserSupport support, Lexer lexer, Object yyVal, Object[] yyVals, int yyTop) {"
-    code_body.each { |line| @out.puts line }
-    @out.puts "    return yyVal;"
-    @out.puts "  }"
-    @out.puts "};"
-  end
-
-  def translate_actions
-    count = 1
-    while (translate_action)
-      count += 1
-    end
-  end
-
-  # Assumptions:
-  # 1. no break; in our code.  A bit weak, but this is highly specialized code.
-  # 2. All productions will have a line containing only { (with optional comment)
-  # 3. All productions will end with a line containly only } followed by break in ass 1.
-  def translate_action
-    line = read
-    return false if end_of_actions?(line) || line !~ /case\s+(\d+):/
-    case_number = $1.to_i
-
-    line = read
-    return false if line !~ /line\s+(\d+)/
-    line_number = $1
-
-    # Extra boiler plate '{' that we do not need
-    line = read
-    return false if line !~ /^\s*\{\s*(\/\*.*\*\/)?$/
-
-    @max_case_number = case_number if case_number > @max_case_number
-
-    label = "case#{case_number}_line#{line_number}"
-
-    body = []
-    last_line = nil
-    while (line = read)
-      if line =~ /^\s*\}\s*$/ # Extra trailing boiler plate
-        next_line = read
-        if next_line =~ /break;/
-          break
-        else
-          body << line
-          unread next_line
-        end
-      else
-        body << line
-      end
-    end
-
-    @case_bodies[case_number] = body
-    true
-  end
-end
-
-PostProcessor.new(ARGV.shift).translate

data/bin/patch_parser.rb

@@ -1,105 +0,0 @@
-def get_numbers_until_end_block(table)
-  while gets
-    break if /\};/ =~ $_
-    next if /^\/\// =~ $_
-    split(/,/).each do |number|
-      n = number.strip
-      table.push(n.to_i) unless n == ""
-    end
-  end
-  table
-end
-
-while gets
-  break if /protected static final short\[\] yyTable = \{/ =~ $_
-  print $_
-end
-
-# A little hacky...gets before ARGV to shift off and open file
-yytable_prefix = ARGV.shift || ''
-
-table4 = get_numbers_until_end_block([])
-
-puts "    protected static final short[] yyTable = #{yytable_prefix}YyTables.yyTable();"
-
-while gets
-  break if /protected static final short\[\] yyCheck = \{/ =~ $_
-  print $_
-end
-
-check4 = get_numbers_until_end_block([])
-
-puts "    protected static final short[] yyCheck = #{yytable_prefix}YyTables.yyCheck();"
-
-while gets
-  print $_
-end
-
-table2 = table4.slice!(0, table4.size / 2)
-table3 = table4.slice!(0, table4.size / 2)
-table1 = table2.slice!(0, table2.size / 2)
-check2 = check4.slice!(0, check4.size / 2)
-check3 = check4.slice!(0, check4.size / 2)
-check1 = check2.slice!(0, check2.size / 2)
-
-def printShortArray(table, f)
-  table.each_with_index { |e, i|
-    f.print "\n         " if (i % 10 == 0)
-    begin
-      f.printf "%4d, ", e
-    rescue ArgumentError => a
-      $stderr.puts "Trouble printing '#{e}' on index #{i}"
-    end
-  }
-end
-
-def printShortMethod(f, table, name)
-  f.puts "   private static final short[] yy#{name}() {"
-  f.puts "      return new short[] {"
-  printShortArray table, f
-  f.puts
-  f.puts "      };"
-  f.puts "   }"
-  f.puts
-end
-
-open("#{yytable_prefix}YyTables.java", "w") { |f|
-  f.print <<END
-package org.jrubyparser.parser;
-
-public class #{yytable_prefix}YyTables {
-   private static short[] combine(short[] t1, short[] t2, 
-                                  short[] t3, short[] t4) {
-      short[] t = new short[t1.length + t2.length + t3.length + t4.length];
-      int index = 0;
-      System.arraycopy(t1, 0, t, index, t1.length);
-      index += t1.length;
-      System.arraycopy(t2, 0, t, index, t2.length);
-      index += t2.length;
-      System.arraycopy(t3, 0, t, index, t3.length);
-      index += t3.length;
-      System.arraycopy(t4, 0, t, index, t4.length);
-      return t;
-   }
-
-   public static final short[] yyTable() {
-      return combine(yyTable1(), yyTable2(), yyTable3(), yyTable4());
-   }
-
-   public static final short[] yyCheck() {
-      return combine(yyCheck1(), yyCheck2(), yyCheck3(), yyCheck4());
-   }
-END
-
-  printShortMethod(f, table1, "Table1")
-  printShortMethod(f, table2, "Table2")
-  printShortMethod(f, table3, "Table3")
-  printShortMethod(f, table4, "Table4")
-
-  printShortMethod(f, check1, "Check1")
-  printShortMethod(f, check2, "Check2")
-  printShortMethod(f, check3, "Check3")
-  printShortMethod(f, check4, "Check4")
-
-  f.puts "}"
-}