jruby-parser 0.4.2 → 0.5.0

data/spec/{jruby-parser → ast/node}/is_block_parameter_spec.rb

@@ -1,11 +1,7 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
-require 'java'
-require 'jruby-parser'
-require 'parser_helpers'
+require_relative '../../helpers'
 
-describe JRubyParser do
-  [1.8, 1.9].each do |v|
+describe org.jrubyparser.ast.Node do
+  VERSIONS.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
@@ -23,7 +19,7 @@ describe JRubyParser do
         caret_node.block_parameter?.should == true
       end
 
-      if v == 1.9
+      if v != 1.8
         caret_parse("proc { |a, ^b=1| }", v).tap do |root, caret_node|
           caret_node.block_parameter?.should == true
         end

data/spec/{jruby-parser → ast/node}/is_method_parameter_spec.rb

@@ -1,11 +1,7 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
-require 'java'
-require 'jruby-parser'
-require 'parser_helpers'
+require_relative '../../helpers'
 
-describe JRubyParser do
-  [1.8, 1.9].each do |v|
+describe org.jrubyparser.ast.Node do
+  VERSIONS.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
@@ -22,7 +18,7 @@ describe JRubyParser do
       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
+      if v != 1.8
         caret_parse("def foo(a, (b, ^c)); end", v).tap do |root, caret_node|
           caret_node.method_parameter?.should == true
         end

data/spec/ast/node/next_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../helpers'
+
+describe org.jrubyparser.ast.NextNode do
+  VERSIONS.each do |v|
+    it "can accept a single value [#{v}]" do
+      rparse("next true", v).find_node(:next).tap do |b|
+        b.should have_position(0, 0, 0, 9)
+        b.value_node.class.should == org.jrubyparser.ast.TrueNode
+      end
+    end
+
+    it "can accept no value [#{v}]" do
+      rparse("next", v).find_node(:next).tap do |b|
+        b.should have_position(0, 0, 0, 4)
+        b.value_node.should == nil
+      end
+    end
+  end
+end

data/spec/ast/node/op_element_asgn_and_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../../helpers'
+
+describe org.jrubyparser.ast.OpElementAsgnAndNode do
+  VERSIONS.each do |v|
+    it "can parse simple expr [#{v}]" do
+      parse("a[1] &&= 2", v).find_node(:opelementasgnand).tap do |op|
+        op.should have_position(0, 0, 0, 10)
+      end
+    end
+  end
+end

data/spec/ast/node/op_element_asgn_or_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../../helpers'
+
+describe org.jrubyparser.ast.OpElementAsgnOrNode do
+  VERSIONS.each do |v|
+    it "can parse simple expr [#{v}]" do
+      parse("a[1] ||= 2", v).find_node(:opelementasgnor).tap do |op|
+        op.should have_position(0, 0, 0, 10)
+      end
+    end
+  end
+end

data/spec/ast/node/op_element_asgn_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../../helpers'
+
+describe org.jrubyparser.ast.OpElementAsgnNode do
+  VERSIONS.each do |v|
+    it "can parse simple expr [#{v}]" do
+      parse("a[1] += 2", v).find_node(:opelementasgn).tap do |op|
+        op.should have_position(0, 0, 0, 9)
+      end
+    end
+  end
+end

data/spec/ast/node/return_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../helpers'
+
+describe org.jrubyparser.ast.ReturnNode do
+  VERSIONS.each do |v|
+    it "can accept a single value [#{v}]" do
+      rparse("return true", v).find_node(:return).tap do |b|
+        b.should have_position(0, 0, 0, 11)
+        b.value_node.class.should == org.jrubyparser.ast.TrueNode
+      end
+    end
+
+    it "can accept no value [#{v}]" do
+      rparse("return", v).find_node(:return).tap do |b|
+        b.should have_position(0, 0, 0, 6)
+        b.value_node.should == nil
+      end
+    end
+  end
+end

data/spec/ast/node_path.rb

@@ -1,8 +1,4 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
-require 'jruby-parser'
-require 'parser_helpers'
-require 'node_helpers'
+require_relative '../../helpers'
 
 describe Parser do
   it "should parse alias with quotationmarks" do

data/spec/helpers.rb

@@ -0,0 +1,4 @@
+require 'jruby-parser'
+
+require_relative 'helpers/node_helpers'
+require_relative 'helpers/parser_helpers'

data/spec/helpers/node_helpers.rb

@@ -12,27 +12,37 @@ end
 ###########
 
 class AstPositionMatcher
-  def initialize(*args)
-    @position = args
+  def initialize(method, *args)
+    @method, @position = method, args
+  end
+
+  def position
+    @actual.__send__(@method).to_a
   end
  
   def matches?(actual)
     @actual = actual
-    actual.position.to_a == @position
+    position == @position
   end
  
   def failure_message
-    return %[expected #{@actual.position.to_a.inspect} to have position #{@position.inspect}]
+    return %[expected #{position.inspect} to have position #{@position.inspect}]
   end
  
   def negative_failure_message
-    return %[expected #{@actual.position.to_a.inspect} to not have position #{@position.inspect}]
+    return %[expected #{position.inspect} to not have position #{@position.inspect}]
   end
 end
  
 module HavePosition
   def have_position(*args)
-    AstPositionMatcher.new(*args)
+    AstPositionMatcher.new(:position, *args)
+  end
+end
+
+module HaveNamePosition
+  def have_name_position(*args)
+    AstPositionMatcher.new(:name_position, *args)
   end
 end
 
@@ -224,6 +234,7 @@ end
 #module Spec::Example::ExampleMethods
 class Object
   include HavePosition
+  include HaveNamePosition
   include HaveName
   include HaveNameAndPosition
   include HaveArgCounts

data/spec/helpers/parser_helpers.rb

@@ -1,13 +1,23 @@
 require 'java'
 
 import java.io.StringReader
+import org.jrubyparser.CompatVersion
 import org.jrubyparser.Parser
+import org.jrubyparser.LocalStaticScope
 import org.jrubyparser.parser.ParserConfiguration
-import org.jrubyparser.CompatVersion
 
 PARSER = Parser.new
-CONFIG_18 = ParserConfiguration.new
-CONFIG_19 = ParserConfiguration.new(0, CompatVersion::RUBY1_9)
+VERSIONS_MAP = {
+  1.8 => CompatVersion::RUBY1_8,  
+  1.9 => CompatVersion::RUBY1_9,  
+  2.0 => CompatVersion::RUBY2_0 
+}
+VERSIONS = [1.8, 1.9, 2.0]
+
+SYNTAX_MAP = {
+  nil => ParserConfiguration::SyntaxGathering::NONE,
+  :all => ParserConfiguration::SyntaxGathering::ALL
+}
 
 class Object
   # Wrap the code in what the JRubyParser expects
@@ -15,10 +25,53 @@ class Object
     StringReader.new code.to_s
   end
 
+  def config(version, scope=nil, syntax=nil)
+    ParserConfiguration.new(0, VERSIONS_MAP[version], scope).tap do |c|
+      c.syntax = SYNTAX_MAP[syntax]
+    end
+  end
+
+  # Create a static scope that we can pass to the parser that has
+  # defined all strings local var names defined within it.
+  def scope(*vars)
+    position = org.jrubyparser.SourcePosition.new("(eval)", 0, 0)
+    LocalStaticScope.new(nil).tap do |scope|
+      vars.each { |e| scope.assign(position, e, nil) }
+    end
+  end
+
   # Parse the provided code into an AST
-  def parse(code, version=1.8)
-    config = version == 1.8  ? CONFIG_18 : CONFIG_19
-    PARSER.parse "<code>", source(code), config
+  def parse(code, version=1.8, scope=nil)
+    PARSER.parse "<code>", source(code), config(version, scope)
+  end
+
+# def node_value(node)
+#   name = node.getClass.name
+
+#   value = node.value if node.respond_to?(:value)
+#   value = node.name if node.respond_to?(:name)
+
+#   name + (value ? ("(" + value.to_s + ")" ) : "")
+# end
+
+# def node_position(node)
+#   node.position 
+# end
+
+# def display(node, indent="")
+#   puts "#{indent}#{node_value(node)}: #{node_position(node)}"
+#   node.child_nodes.each do |child|
+#     display(child, indent + "  ")
+#   end
+# end
+
+
+  # Parse the provided code into an AST with full syntax collection.
+  # The 'r' is for rewriting...
+  def rparse(code, version=1.8, scope=nil)
+    root = PARSER.parse "<code>", source(code), config(version, scope, :all)
+#    display(root)
+    root
   end
 
   ##
@@ -26,11 +79,34 @@ class Object
   # 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='^')
+  def caret_parse(code, version=1.8, caret='^', scope=nil)
     caret_index = code.index(caret)
     raise ArgumentError.new("Caret '^' missing: #{code}") unless caret_index
 
-    root = parse(code.sub(caret, ''), version)
+    root = parse code.sub(caret, ''), version, scope
     [root, root.node_at(caret_index)]
   end
+
+  ##
+  # parse code but record all '^' found in source and return a list of all
+  # nodes found at those carets.
+  def carets_parse(code, version=1.8, caret='^', scope=nil)
+    deloused_code, caret_indices = remove_carets(code, caret)
+    root = parse deloused_code, version, scope
+    [root, caret_indices.map { |e| root.node_at(e)}]
+  end
+
+  # Pretty naive impl :)
+  def remove_carets(code, caret)
+    indices = []
+    index = code.index(caret)
+
+    while index
+      indices << index
+      code.sub!(caret, '')
+      index = code.index(caret)
+    end
+
+    [code, indices]
+  end
 end

data/spec/jruby-parser/find_spec.rb

@@ -1,11 +1,7 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
-require 'java'
-require 'jruby-parser'
-require 'parser_helpers'
+require_relative '../helpers'
 
 describe JRubyParser do
-  [1.8, 1.9].each do |v|
+  VERSIONS.each do |v|
     it "finds fcall via simple symbol search [#{v}]" do
       parse("b = foo(1)").tap do |root|
         fcall = root.find_type(:fcall)

data/spec/jruby-parser/parse_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../helpers'
+
+describe JRubyParser do
+  VERSIONS.each do |v|
+    it "passes in a static scope with defined var [#{v}]" do
+      parse("b = a", v, scope('a')).tap do |root|
+        root.find_type(:localvar).should_not == nil # a
+      end
+    end
+
+    it "parses hash literal with trailing = at end of key name" do
+      parse("{:a==>1}").tap do |root|
+        root.find_type(:symbol).name.should == "a="
+      end
+    end
+  end
+end

data/spec/jruby-parser/rewriting_spec.rb

@@ -1,10 +1,9 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
-require 'jruby-parser'
+require_relative '../helpers'
 
 describe JRubyParser do
-  [1.8, 1.9].each do |v|
+  VERSIONS.each do |v|
     it "rewrites method name from foo to bar [#{v}]" do
-      parse("b = foo(1)").tap do |root|
+      rparse("b = foo(1)").tap do |root|
         fcall = root.find_node(:fcall)
         fcall.name = 'bar'
       end.to_source.should == "b = bar(1)"
@@ -15,14 +14,14 @@ describe JRubyParser do
       end.to_source.should == "b = bar 1"
     end
 
-    it "rewrites between different coercible ruby types [#{v}]" do
-      [1, 1.0, true, false, nil, "a"].each do |replace|
-        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 between different coercible ruby types [#{v}]" do
+     [1, 1.0, true, false, nil, "a"].each do |replace|
+       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 [#{v}]" do
       parse("1.to_f(1)").tap do |root|
@@ -53,5 +52,21 @@ describe JRubyParser do
         op.value = 3
       end.to_source.should == "1[2] += 3"
     end
+
+    it "rewrites an alias of barewords [#{v}]" do
+      parse("alias foo bar").to_source.should == "alias foo bar"
+    end
+
+    if v != 1.8 
+      it "rewrites stabby lambda [#{v}]" do
+        str = "->(a) {puts a}"
+        parse(str, v).to_source.should == str
+      end
+    end
+
+#    it "rewrites a comment on first line [#{v}]" do
+#      code = "# comment 1\nfoo(1)\n"
+#      rparse(code).to_source.should == code
+#    end
   end
 end

data/spec/jruby-parser/static_analysis_spec.rb

@@ -1,66 +1,69 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
-require 'jruby-parser'
-require 'parser_helpers'
-require 'node_helpers'
+require_relative '../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]])
+  VERSIONS.each do |v|
+    if v == 2.0
+      it "test 2.0" do
+        parse("def foo(a:1); p a; end", v)
       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]]])
+    if v != 1.8
+      it "parses a simple multiple assignment [#{v}]" do
+        parse("a,b,c = 1,2,3", v).find_node(:multipleasgn).tap do |masgn|
+          masgn.should have_static_assignments([[:a, 1], [:b, 2], [:c, 3]])
+        end
       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]])
+      it "parses a simple lhs splat multiple assignment [#{v}]" do
+        parse("a,*b = 1,2,3", v).find_node(:multipleasgn).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(:multipleasgn).tap do |masgn|
+          masgn.should have_static_assignments([[:a, 1], [:b, 2], [:c, [3,4]]])
+        end
       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]])
+      it "parses a simple lhs splat multiple assignment [#{v}]" do
+        parse("*a,b = 1,2,3", v).find_node(:multipleasgn).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(:multipleasgn).tap do |masgn|
+          masgn.should have_static_assignments([[:a, [1, 2]], [:b, 3], [:c, 4]])
+        end
       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]])
+
+      it "parses a simple lhs splat multiple assignment [#{v}]" do
+        parse("a,*b, c = 1,2,3,4", v).find_node(:multipleasgn).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(:multipleasgn).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(:multipleasgn).tap do |masgn|
+          masgn.should have_static_assignments([[:a, 1], [:b, [2, 3]], [:c, 4], [:d, 5]])
+        end
       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]])
+      it "parses a simple lhs splat multiple assignment [#{v}]" do
+        parse("a,*b,c,d = 1,2,3", v).find_node(:multipleasgn).tap do |masgn|
+          masgn.should have_static_assignments([[:a, 1], [:b, []], [:c, 2], [:d, 3]])
+        end
       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]])
+      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(:multipleasgn).tap do |masgn|
+          masgn.should have_static_assignments([[:a, 1], [:b, foo]])
+        end
       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]])
+      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(:multipleasgn).tap do |masgn|
+          masgn.should have_static_assignments([[:a, splatted_foo], [:b, 1]])
+        end
       end
     end