parser 2.0.0.pre2 → 2.0.0.pre3

data/test/test_parser.rb

@@ -794,12 +794,12 @@ class TestParser < Minitest::Test
     assert_diagnoses(
       [:error, :dynamic_const],
       %q{def f; Foo::Bar = 1; end},
-      %q{            ~~~ location})
+      %q{       ~~~~~~~~ location})
 
     assert_diagnoses(
       [:error, :dynamic_const],
       %q{def f; ::Bar = 1; end},
-      %q{         ~~~ location})
+      %q{       ~~~~~ location})
   end
 
   # Multiple assignment
@@ -1044,12 +1044,12 @@ class TestParser < Minitest::Test
     assert_diagnoses(
       [:error, :dynamic_const],
       %q{def f; self::A, foo = foo; end},
-      %q{             ~ location})
+      %q{       ~~~~~~~ location})
 
     assert_diagnoses(
       [:error, :dynamic_const],
       %q{def f; ::A, foo = foo; end},
-      %q{         ~ location})
+      %q{       ~~~ location})
   end
 
   # Variable binary operator-assignment
@@ -1114,6 +1114,24 @@ class TestParser < Minitest::Test
       %q{B::A += 1},
       %q{},
       ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:def, :x, s(:args),
+        s(:or_asgn,
+          s(:casgn, s(:self), :A),
+          s(:int, 1))),
+      %q{def x; self::A ||= 1; end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:def, :x, s(:args),
+        s(:or_asgn,
+          s(:casgn, s(:cbase), :A),
+          s(:int, 1))),
+      %q{def x; ::A ||= 1; end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
   end
 
   def test_const_op_asgn_invalid
@@ -1132,12 +1150,14 @@ class TestParser < Minitest::Test
     assert_diagnoses(
       [:error, :dynamic_const],
       %q{def foo; Foo::Bar += 1; end},
-      %q{              ~~~ location})
+      %q{              ~~~ location},
+      %w(1.8 1.9))
 
     assert_diagnoses(
       [:error, :dynamic_const],
       %q{def foo; ::Bar += 1; end},
-      %q{           ~~~ location})
+      %q{           ~~~ location},
+      %w(1.8 1.9))
   end
 
   # Method binary operator-assignment
@@ -2191,6 +2211,14 @@ class TestParser < Minitest::Test
       ALL_VERSIONS - %w(1.8 1.9))
   end
 
+  def test_block_kwarg
+    assert_parses_blockargs(
+      s(:args,
+        s(:kwarg, :foo)),
+      %q{|foo:|},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
   def test_arg_invalid
     assert_diagnoses(
       [:error, :argument_const],
@@ -2312,6 +2340,22 @@ class TestParser < Minitest::Test
       ALL_VERSIONS - %w(1.8 1.9))
   end
 
+  def test_arg_duplicate_proc
+    assert_parses(
+      s(:block, s(:send, nil, :proc),
+        s(:args, s(:arg, :a), s(:arg, :a)),
+        nil),
+      %q{proc{|a,a|}},
+      %q{},
+      %w(1.8))
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{proc{|a,a|}},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
   def test_kwarg_invalid
     assert_diagnoses(
       [:error, :argument_const],
@@ -3180,17 +3224,37 @@ class TestParser < Minitest::Test
         s(:args), nil),
       %q{fun (1) {}})
 
+    assert_parses(
+      s(:block,
+        s(:send, s(:lvar, :foo), :fun, s(:int, 1)),
+        s(:args), nil),
+      %q{foo.fun (1) {}},
+      %q{},
+      %w(1.8))
+
     assert_parses(
       s(:block,
         s(:send, s(:lvar, :foo), :fun, s(:begin, s(:int, 1))),
         s(:args), nil),
-      %q{foo.fun (1) {}})
+      %q{foo.fun (1) {}},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:block,
+        s(:send, s(:lvar, :foo), :fun, s(:int, 1)),
+        s(:args), nil),
+      %q{foo::fun (1) {}},
+      %q{},
+      %w(1.8))
 
     assert_parses(
       s(:block,
         s(:send, s(:lvar, :foo), :fun, s(:begin, s(:int, 1))),
         s(:args), nil),
-      %q{foo::fun (1) {}})
+      %q{foo::fun (1) {}},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
   end
 
   def test_space_args_arg_call
@@ -3667,12 +3731,28 @@ class TestParser < Minitest::Test
     assert_diagnoses(
       [:error, :masgn_as_condition],
       %q{if foo && (a, b = bar); end},
-      %q{           ~~~~~~~~~~ location})
+      %q{           ~~~~~~~~~~ location},
+      ALL_VERSIONS - %w(1.8))
 
     assert_diagnoses(
       [:error, :masgn_as_condition],
       %q{if foo || (a, b = bar); end},
-      %q{           ~~~~~~~~~~ location})
+      %q{           ~~~~~~~~~~ location},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:if,
+        s(:and,
+          s(:begin,
+            s(:masgn,
+              s(:mlhs,
+                s(:lvasgn, :a), s(:lvasgn, :b)),
+              s(:lvar, :foo))),
+          s(:lvar, :bar)),
+        nil, nil),
+      %q{if (a, b = foo) && bar; end},
+      %q{},
+      %w(1.8))
   end
 
   def test_cond_iflipflop
@@ -4297,7 +4377,7 @@ class TestParser < Minitest::Test
       assert_equal s(:lvar, :foo),
                    ast
 
-      assert_equal range.call(2, 5),
+      assert_equal range.call(1, 4),
                    ast.loc.expression
     end
   end
@@ -4315,6 +4395,46 @@ class TestParser < Minitest::Test
       ALL_VERSIONS - %w(1.8 1.9))
   end
 
+  def test_bug_cmdarg
+    assert_parses(
+      s(:send, nil, :meth,
+        s(:begin,
+          s(:block,
+            s(:send, nil, :lambda),
+            s(:args), nil))),
+      %q{meth (lambda do end)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :assert,
+        s(:send, nil, :dogs)),
+      %q{assert dogs})
+
+    assert_parses(
+      s(:send, nil, :assert,
+        s(:hash,
+          s(:pair, s(:sym, :do), s(:true)))),
+      %q{assert do: true},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :f,
+        s(:hash,
+          s(:pair,
+            s(:sym, :x),
+            s(:block,
+              s(:send, nil, :lambda),
+              s(:args),
+              s(:block,
+                s(:send, nil, :meth),
+                s(:args), nil))))),
+      %q{f x: -> do meth do end end},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
   def test_file_line_non_literals
     with_versions(ALL_VERSIONS) do |_ver, parser|
       parser.builder.emit_file_line_as_literals = false
@@ -4349,6 +4469,18 @@ class TestParser < Minitest::Test
         %q{},
         %w(1.9 2.0 2.1))
     end
+
+    def test_regexp_encoding
+      assert_parses(
+        s(:match_with_lvasgn,
+          s(:regexp,
+            s(:str, "\\xa8"),
+            s(:regopt, :n)),
+          s(:str, "")),
+        %q{/\xa8/n =~ ""}.force_encoding(Encoding::UTF_8),
+        %{},
+        ALL_VERSIONS - %w(1.8))
+    end
   end
 
   #
@@ -4480,4 +4612,46 @@ class TestParser < Minitest::Test
       s(:def, :foo, s(:args), nil),
       %Q{def foo\n=begin\n=end\nend})
   end
+
+  def test_bug_while_not_parens_do
+    assert_parses(
+      s(:while, s(:send, s(:begin, s(:true)), :"!"), nil),
+      %q{while not (true) do end},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_bug_rescue_empty_else
+    assert_parses(
+      s(:kwbegin,
+        s(:rescue, nil,
+          s(:resbody,
+            s(:array,
+              s(:const, nil, :LoadError)), nil, nil), nil)),
+      %q{begin; rescue LoadError; else; end},
+      %q{                         ~~~~ else (rescue)
+        |       ~~~~~~~~~~~~~~~~~~~~~~ expression (rescue)})
+  end
+
+  def test_bug_heredoc_do
+    assert_parses(
+      s(:block,
+        s(:send, nil, :f,
+          s(:dstr)),
+        s(:args), nil),
+      %Q{f <<-TABLE do\nTABLE\nend})
+  end
+
+  def test_bug_lambda_leakage
+    assert_parses(
+      s(:begin,
+        s(:block,
+          s(:send, nil, :lambda),
+          s(:args,
+            s(:arg, :scope)), nil),
+        s(:send, nil, :scope)),
+      %q{->(scope) {}; scope},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre2
+  version: 2.0.0.pre3
 platform: ruby
 authors:
 - Peter Zotov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-11 00:00:00.000000000 Z
+date: 2013-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -198,6 +198,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: gauntlet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A Ruby parser written in pure Ruby.
 email:
 - whitequark@whitequark.org
@@ -224,6 +238,7 @@ files:
 - doc/INTERNALS.md
 - doc/css/.gitkeep
 - doc/css/common.css
+- lib/gauntlet_parser.rb
 - lib/parser.rb
 - lib/parser/all.rb
 - lib/parser/ast/node.rb