jruby-parser 0.3

data/spec/helpers/parser_helpers.rb

@@ -0,0 +1,23 @@
+require 'java'
+
+import java.io.StringReader
+import org.jrubyparser.Parser
+import org.jrubyparser.parser.ParserConfiguration
+import org.jrubyparser.CompatVersion
+
+PARSER = Parser.new
+CONFIG_18 = ParserConfiguration.new
+CONFIG_19 = ParserConfiguration.new(0, CompatVersion::RUBY1_9)
+
+class Object
+  # Wrap the code in what the JRubyParser expects
+  def source(code)
+    StringReader.new code.to_s
+  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
+  end
+end

data/spec/jruby-parser/find_spec.rb

@@ -0,0 +1,30 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+require 'java'
+require 'jruby-parser'
+
+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|
+        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|
+        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|
+        fcall = root.find { |n| n.short_name == "fcall" && n.name == "bar"}
+        fcall.name.should == "bar"
+        fcalls = root.find_all { |n| n.short_name == "fcall" }
+        fcalls.size.should == 2
+      end
+    end
+  end
+end

data/spec/jruby-parser/rewriting_spec.rb

@@ -0,0 +1,57 @@
+$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|
+        fcall = root.find_node(:fcall)
+        fcall.name = 'bar'
+      end.to_source.should == "b = bar(1)"
+
+      JRubyParser.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
+      [1, 1.0, true, false, nil, "a"].each do |replace|
+        JRubyParser.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|
+        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|
+        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|
+        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|
+        op = root.find_node(:opelementasgn)
+        op.receiver = 1
+        op.args[0] = 2
+        op.value = 3
+      end.to_source.should == "1[2] += 3"
+    end
+  end
+end

data/spec/parser/alias_spec.rb

@@ -0,0 +1,18 @@
+$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 alias with quotationmarks" do
+      parse(%Q{alias :'<==>' :"foo"}, v).find_node(:alias).tap do |aliasn|
+        aliasn.new_name.find_node(:symbol).name.should == "<==>"
+        aliasn.old_name.find_node(:symbol).name.should == "foo"
+        aliasn.should have_position(0,0,0,20)
+      end
+    end
+  end
+end
+

data/spec/parser/broken_spec.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+require 'jruby-parser'
+require 'parser_helpers'
+require 'node_helpers'
+
+import org.jrubyparser.lexer.StringTerm
+import org.jrubyparser.lexer.SyntaxException
+
+# tests for broken files
+describe Parser do
+  [1.8, 1.9].each do |v|
+    it "should raise an unterminated string exception" do
+      lambda {
+        parse('str = "', v)
+      }.should raise_error StringTerm::UnterminatedStringException
+    end
+
+    it "should raise a syntax exception" do
+      lambda {
+        parse("class Foo\n   def\nend\n", v)
+      }.should raise_error SyntaxException
+    end
+  end
+end

data/spec/positions/arg_spec.rb

@@ -0,0 +1,129 @@
+$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 "parses a 0-arg method sans parens [#{v}]" 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)
+      end
+    end
+
+    it "parses a 0-arg method with parens [#{v}]" 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)
+      end
+    end
+
+    it "parses a 1-arg method sans parens [#{v}]" 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.pre.tap do |pre|
+          pre.should have_position(0, 0, 8, 9)
+          pre[0].should have_name_and_position("a", 0, 0, 8, 9)
+        end
+      end
+    end
+
+    it "parses a 1-arg method with parens [#{v}]" 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.pre.tap do |pre|
+          pre.should have_position(0, 0, 8, 9)
+          pre[0].should have_name_and_position("a", 0, 0, 8, 9)
+        end
+      end
+    end
+
+    it "parses a 2-arg method sans parens [#{v}]" 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.pre.tap do |pre|
+          pre.should have_position(0, 0, 8, 12)
+          pre[0].should have_name_and_position("a", 0, 0, 8, 9)
+          pre[1].should have_name_and_position("b", 0, 0, 11, 12)
+        end
+      end
+    end
+
+    it "parses a 2-arg method with parens [#{v}]" 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.pre.tap do |pre|
+          pre.should have_position(0, 0, 8, 12)
+          pre[0].should have_name_and_position("a", 0, 0, 8, 9)
+          pre[1].should have_name_and_position("b", 0, 0, 11, 12)
+        end
+      end
+    end
+
+    it "parses a 1-optarg method sans parens [#{v}]" 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)
+        lasgn = defn.args_node.optional.find_node(:localasgn)
+        lasgn.should have_name_and_position("a", 0, 0, 8, 11)
+      end
+    end
+
+    it "parses a 1-optarg method with parens [#{v}]" 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)
+        lasgn = defn.args_node.optional.find_node(:localasgn)
+        lasgn.should have_name_and_position("a", 0, 0, 8, 11)
+      end
+    end
+
+    it "parses a rest-arg method sans parens [#{v}]" 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)
+      end
+    end
+
+    it "parses a rest-arg method with parens [#{v}]" 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)
+      end
+    end
+
+    it "parses a block-arg method sans parens [#{v}]" 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)
+      end
+    end
+
+    it "parses a block-arg method with parens [#{v}]" 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)
+      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)
+      end
+    end
+
+    it "parses a mixed-arg method with 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, 28)
+        defn.args_node.should have_arg_counts(2, 1, true, false)
+      end
+    end
+  end
+end

data/spec/positions/call_spec.rb

@@ -0,0 +1,132 @@
+$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 "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)
+      end
+    end
+    
+    it "parses a 0-arg method call with parens [#{v}]" do
+      parse("puts()", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("puts", 0, 0, 0, 6)
+        call.args_node.size.should == 0
+      end
+    end
+
+    it "parses a 1-arg method call with parens [#{v}]" do
+      parse("puts(1)", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("puts", 0, 0, 0, 7)
+        call.args_node.size.should == 1
+      end
+    end
+
+    it "parses a 1-arg method call without parens [#{v}]" do
+      parse("puts 1", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("puts", 0, 0, 0, 6)
+        call.args_node.size.should == 1
+      end
+    end
+
+    it "parses a 2-arg method call with parens [#{v}]" do
+      parse("puts(1,2)", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("puts", 0, 0, 0, 9)
+        call.args_node.size.should == 2
+      end
+    end
+
+    it "parses a 2-arg method call without parens [#{v}]" do
+      parse("puts 1, 2", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("puts", 0, 0, 0, 9)
+        call.args_node.size.should == 2
+      end
+    end
+
+    it "parses a 0-arg object.method call without parens [#{v}]" do
+      parse("Array.new", v).find_node(:call).tap do |call|
+        call.should have_name_and_position("new", 0, 0, 0, 9)
+        call.receiver_node.should have_name_and_position("Array", 0, 0, 0, 5)
+        call.args_node.size.should == 0
+      end
+    end
+
+    it "parses a 0-arg object.method call with parens [#{v}]" do
+      parse("Array.new()", v).find_node(:call).tap do |call|
+        call.should have_name_and_position("new", 0, 0, 0, 11)
+        call.receiver_node.should have_name_and_position("Array", 0, 0, 0, 5)
+        call.args_node.size.should == 0
+      end
+    end
+
+    it "parses a 1-arg object.method call without parens [#{v}]" do
+      parse("Array.new 1", v).find_node(:call).tap do |call|
+        call.should have_name_and_position("new", 0, 0, 0, 11)
+        call.receiver_node.should have_name_and_position("Array", 0, 0, 0, 5)
+        call.args_node.size.should == 1
+      end
+    end
+
+    it "parses a 1-arg object.method call with parens [#{v}]" do
+      parse("Array.new(1)", v).find_node(:call).tap do |call|
+        call.should have_name_and_position("new", 0, 0, 0, 12)
+        call.receiver_node.should have_name_and_position("Array", 0, 0, 0, 5)
+        call.args_node.size.should == 1
+      end
+    end
+    
+    it "parses a 1-arg infix method [#{v}]" do
+      parse("4 + 5", v).find_node(:call).tap do |call|
+        call.should have_name_and_position("+", 0, 0, 0, 5)
+        call.receiver_node.should have_position(0, 0, 0, 1)
+        call.args_node.size.should == 1
+      end
+    end
+
+    it "parses a 1-arg object.method call with infix operator as arg [#{v}]" do
+      parse("Array.new 4 + 5", v).find_node(:call).tap do |call|
+        call.should have_name_and_position("new", 0, 0, 0, 15)
+        call.receiver_node.should have_name_and_position("Array", 0, 0, 0, 5)
+        call.args_node.size.should == 1
+      end
+    end
+
+    it "parses an empty method with a block({}) [#{v}]" do
+      parse("foo() {}", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("foo", 0, 0, 0, 8)
+        call.iter_node.should have_position(0, 0, 6, 8)
+      end
+    end
+
+    it "parses an empty method with a block(do...end) [#{v}]" do
+      parse("foo() do\nend\n", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("foo", 0, 1, 0, 12)
+        call.iter_node.should have_position(0, 1, 6, 12)
+      end
+    end
+
+    it "parses an empty method with a block({}) +1 arg [#{v}]" do
+      parse("foo() { |a| }", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("foo", 0, 0, 0, 13)
+        call.iter_node.should have_position(0, 0, 6, 13)
+        # FIXME: Need arg tests
+      end
+    end
+
+    it "parses an empty method with a block(do...end) [#{v}]" do
+      parse("foo() do |a|\nend\n", v).find_node(:fcall).tap do |call|
+        call.should have_name_and_position("foo", 0, 1, 0, 16)
+        call.iter_node.should have_position(0, 1, 6, 16)
+        # FIXME: Need arg tests
+      end
+    end
+
+    it "parses an nil receiver [#{v}]" do
+      parse("().foo", v).find_node(:call).receiver_node.should_not be_nil
+    end
+  end
+end

data/spec/positions/conditionals_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 an unless on alias [#{v}]" do
+      ast = parse("alias p ** unless method_defined? :p", v)
+      ast.find_node(:alias).tap { |a| a.should have_position(0, 0, 0, 10) }
+      ast.find_node(:if).tap { |i| i.should have_position(0, 0, 0, 36) }
+    end
+  end
+end

data/spec/positions/hash_spec.rb

@@ -0,0 +1,25 @@
+$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 a hash literal (a=>b) [#{v}]" do
+      parse("{:one => 1, :two => 2}", v).find_node(:hash).tap do |hash|
+        hash.should have_position(0, 0, 0, 22)
+      end
+    end
+  end
+
+  it "should parse a hash literal (a,b) [1.8]" do
+    parse("{:one, 1, :two, 2}", 1.8).find_node(:hash).tap do |hash|
+      hash.should have_position(0, 0, 0, 18)
+    end
+  end
+
+  it "should parse a hash literal (a: b) [1.9]" do
+    parse("{one: 1, two: 2}", 1.9).find_node(:hash).should have_position(0, 0, 0, 16)
+  end
+end

data/spec/positions/heredoc_spec.rb

@@ -0,0 +1,109 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../helpers"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../lib"
+require 'jruby-parser'
+require 'parser_helpers'
+require 'node_helpers'
+
+# Notes:
+# 1. All heredocs include end newline right after end marker because that whitespace is part of
+#    the markers definition.
+
+describe Parser do
+  [1.8, 1.9].each do |v|
+    it "parses a heredoc with marker at beginning of line[#{v}]" do
+    ast = parse(<<-EOF, v)
+<<END
+hello
+END
+    EOF
+
+    ast.find_node(:str).should have_position(0, 2, 0, 15)
+  end
+
+  it "parses an empty heredoc with marker at beginning of line[#{v}]" do
+    ast = parse(<<-EOF, v)
+<<END
+END
+    EOF
+
+    ast.find_node(:str).should have_position(0, 1, 0, 9)
+  end
+
+  it "parses a heredoc with minus(-) and marker not at beginning of line[#{v}]" do
+    ast = parse(<<-EOF, v)
+<<-END
+hello
+ END
+    EOF
+
+    ast.find_node(:str).should have_position(0, 2, 0, 17)
+  end
+
+  it "parses an empty heredoc with minus(-) and marker not at beginning of line[#{v}]" do
+    ast = parse(<<-EOF, v)
+<<-END
+ END
+    EOF
+
+    ast.find_node(:str).should have_position(0, 1, 0, 11)
+  end
+
+  it "parses a heredoc in quotes with marker at beginning of line[#{v}]" do
+    ast = parse(<<-EOF, v)
+<<'END'
+hello
+END
+    EOF
+
+    ast.find_node(:str).should have_position(0, 2, 0, 17)
+  end
+
+  it "parses a heredoc in quotes with minus(-) and marker not at beginning of line[#{v}]" do
+    ast = parse(<<-EOF, v)
+<<-'END'
+hello
+ END
+    EOF
+
+    ast.find_node(:str).should have_position(0, 2, 0, 19)
+  end
+
+  it "parses a heredoc in double quotes with minus(-) and marker not at beginning of line[#{v}]" do
+    ast = parse(<<-EOF, v)
+<<-"end;"
+hello
+ end;
+    EOF
+
+    ast.find_node(:str).should have_position(0, 2, 0, 21)
+  end
+
+  it "parses an empty heredoc in double quotes with minus(-) and marker not at beginning of line[#{v}]" do
+    ast = parse(<<-EOF, v)
+<<-"end;"
+ end;
+    EOF
+
+    ast.find_node(:str).should have_position(0, 1, 0, 15)
+  end
+
+  it "parses a heredoc in method call with other arguments[#{v}]" do
+    ast = parse(<<-EOF, v)
+module_eval <<-"end;", "file", 123
+  hello world
+ end;
+    EOF
+
+    ast.find_node(:str).should have_position(0, 2, 12, 41)
+  end
+
+  it "parses an empty heredoc in method call with other arguments[#{v}]" do
+    ast = parse(<<-EOF, v)
+module_eval <<-"end;", "file", 123
+ end;
+    EOF
+
+    ast.find_node(:str).should have_position(0, 1, 12, 27)
+  end
+end
+end

data/spec/positions/str_spec.rb

@@ -0,0 +1,13 @@
+$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 a string value [#{v}]" do
+      parse('str = "my str"', v).find_node(:str).value.should == "my str"
+    end
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-parser
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  version: "0.3"
+platform: ruby
+authors: 
+- Thomas E. Enebo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-18 00:00:00 -05:00
+default_executable: 
+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
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/jruby-parser.rb
+- lib/jruby-parser/core_ext/array.rb
+- lib/jruby-parser/core_ext/attr_assign_node.rb
+- lib/jruby-parser/core_ext/boolean.rb
+- lib/jruby-parser/core_ext/call_node.rb
+- lib/jruby-parser/core_ext/fcall_node.rb
+- lib/jruby-parser/core_ext/list_node.rb
+- lib/jruby-parser/core_ext/nil.rb
+- lib/jruby-parser/core_ext/node.rb
+- lib/jruby-parser/core_ext/numeric.rb
+- lib/jruby-parser/core_ext/op_element_asgn_node.rb
+- lib/jruby-parser/core_ext/string.rb
+- lib/jruby-parser/core_ext/super_node.rb
+- lib/jruby-parser/util/coercer.rb
+- lib/jruby-parser/version.rb
+- lib/yydebug.jar
+- sample/simple.rb
+- spec/ast/node_path.rb
+- spec/helpers/node_helpers.rb
+- spec/helpers/parser_helpers.rb
+- spec/jruby-parser/find_spec.rb
+- spec/jruby-parser/rewriting_spec.rb
+- spec/parser/alias_spec.rb
+- spec/parser/broken_spec.rb
+- spec/positions/arg_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: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: jruby-parser
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Gem for syntactically correct parse trees of Ruby source
+test_files: 
+- spec/ast/node_path.rb
+- spec/helpers/node_helpers.rb
+- spec/helpers/parser_helpers.rb
+- spec/jruby-parser/find_spec.rb
+- spec/jruby-parser/rewriting_spec.rb
+- spec/parser/alias_spec.rb
+- spec/parser/broken_spec.rb
+- spec/positions/arg_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