ripper_ruby_parser 1.7.2 → 1.10.0

data/test/ripper_ruby_parser/parser_test.rb

@@ -1,576 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-
-describe RipperRubyParser::Parser do
-  let(:parser) { RipperRubyParser::Parser.new }
-  describe "#parse" do
-    it "returns an s-expression" do
-      result = parser.parse "foo"
-      _(result).must_be_instance_of Sexp
-    end
-
-    describe "for an empty program" do
-      it "returns nil" do
-        _("").must_be_parsed_as nil
-      end
-    end
-
-    describe "for a class declaration" do
-      it "works with a namespaced class name" do
-        _("class Foo::Bar; end")
-          .must_be_parsed_as s(:class,
-                               s(:colon2, s(:const, :Foo), :Bar),
-                               nil)
-      end
-
-      it "works for singleton classes" do
-        _("class << self; end").must_be_parsed_as s(:sclass, s(:self))
-      end
-    end
-
-    describe "for a module declaration" do
-      it "works with a simple module name" do
-        _("module Foo; end")
-          .must_be_parsed_as s(:module, :Foo)
-      end
-
-      it "works with a namespaced module name" do
-        _("module Foo::Bar; end")
-          .must_be_parsed_as s(:module,
-                               s(:colon2, s(:const, :Foo), :Bar))
-      end
-    end
-
-    describe "for empty parentheses" do
-      it "works with lone ()" do
-        _("()").must_be_parsed_as s(:nil)
-      end
-    end
-
-    describe "for a begin..end block" do
-      it "works with no statements" do
-        _("begin; end")
-          .must_be_parsed_as s(:nil)
-      end
-
-      it "works with one statement" do
-        _("begin; foo; end")
-          .must_be_parsed_as s(:call, nil, :foo)
-      end
-
-      it "works with multiple statements" do
-        _("begin; foo; bar; end")
-          .must_be_parsed_as s(:block,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-    end
-
-    describe "for arguments" do
-      it "works for a simple case with splat" do
-        _("foo *bar")
-          .must_be_parsed_as s(:call,
-                               nil,
-                               :foo,
-                               s(:splat, s(:call, nil, :bar)))
-      end
-
-      it "works for a multi-argument case with splat" do
-        _("foo bar, *baz")
-          .must_be_parsed_as s(:call,
-                               nil,
-                               :foo,
-                               s(:call, nil, :bar),
-                               s(:splat, s(:call, nil, :baz)))
-      end
-
-      it "works for a simple case passing a block" do
-        _("foo &bar")
-          .must_be_parsed_as s(:call, nil, :foo,
-                               s(:block_pass,
-                                 s(:call, nil, :bar)))
-      end
-
-      it "works for a bare hash" do
-        _("foo bar => baz")
-          .must_be_parsed_as s(:call, nil, :foo,
-                               s(:hash,
-                                 s(:call, nil, :bar),
-                                 s(:call, nil, :baz)))
-      end
-    end
-
-    describe "for the __ENCODING__ keyword" do
-      it "evaluates to the equivalent of Encoding::UTF_8" do
-        _("__ENCODING__")
-          .must_be_parsed_as s(:colon2, s(:const, :Encoding), :UTF_8)
-      end
-    end
-
-    describe "for the __FILE__ keyword" do
-      describe "when not passing a file name" do
-        it "creates a string sexp with value '(string)'" do
-          _("__FILE__")
-            .must_be_parsed_as s(:str, "(string)")
-        end
-      end
-
-      describe "when passing a file name" do
-        it "creates a string sexp with the file name" do
-          result = parser.parse "__FILE__", "foo"
-          _(result).must_equal s(:str, "foo")
-        end
-      end
-    end
-
-    describe "for the __LINE__ keyword" do
-      it "creates a literal sexp with value of the line number" do
-        _("__LINE__")
-          .must_be_parsed_as s(:lit, 1)
-        _("\n__LINE__")
-          .must_be_parsed_as s(:lit, 2)
-      end
-    end
-
-    describe "for the END keyword" do
-      it "converts to a :postexe iterator" do
-        _("END { foo }")
-          .must_be_parsed_as s(:iter, s(:postexe), 0, s(:call, nil, :foo))
-      end
-
-      it "works with an empty block" do
-        _("END { }")
-          .must_be_parsed_as s(:iter, s(:postexe), 0)
-      end
-
-      it "assigns correct line numbers" do
-        _("END {\nfoo\n}")
-          .must_be_parsed_as s(:iter,
-                               s(:postexe).line(1), 0,
-                               s(:call, nil, :foo).line(2)).line(1),
-                             with_line_numbers: true
-      end
-
-      it "assigns correct line numbers to a embedded begin block" do
-        _("END {\nbegin\nfoo\nend\n}")
-          .must_be_parsed_as s(:iter,
-                               s(:postexe).line(1), 0,
-                               s(:call, nil, :foo).line(3)).line(1),
-                             with_line_numbers: true
-      end
-    end
-
-    describe "for the BEGIN keyword" do
-      it "converts to a :preexe iterator" do
-        _("BEGIN { foo }")
-          .must_be_parsed_as s(:iter, s(:preexe), 0, s(:call, nil, :foo))
-      end
-
-      it "works with an empty block" do
-        _("BEGIN { }")
-          .must_be_parsed_as s(:iter, s(:preexe), 0)
-      end
-
-      it "assigns correct line numbers" do
-        _("BEGIN {\nfoo\n}")
-          .must_be_parsed_as s(:iter,
-                               s(:preexe).line(1), 0,
-                               s(:call, nil, :foo).line(2)).line(1),
-                             with_line_numbers: true
-      end
-
-      it "assigns correct line numbers to a embedded begin block" do
-        _("BEGIN {\nbegin\nfoo\nend\n}")
-          .must_be_parsed_as s(:iter,
-                               s(:preexe).line(1), 0,
-                               s(:begin,
-                                 s(:call, nil, :foo).line(3)).line(2)).line(1),
-                             with_line_numbers: true
-      end
-    end
-
-    describe "for constant lookups" do
-      it "works when explicitely starting from the root namespace" do
-        _("::Foo")
-          .must_be_parsed_as s(:colon3, :Foo)
-      end
-
-      it "works with a three-level constant lookup" do
-        _("Foo::Bar::Baz")
-          .must_be_parsed_as s(:colon2,
-                               s(:colon2, s(:const, :Foo), :Bar),
-                               :Baz)
-      end
-
-      it "works looking up a constant in a non-constant" do
-        _("foo::Bar").must_be_parsed_as s(:colon2,
-                                          s(:call, nil, :foo),
-                                          :Bar)
-      end
-    end
-
-    describe "for variable references" do
-      it "works for self" do
-        _("self")
-          .must_be_parsed_as s(:self)
-      end
-
-      it "works for instance variables" do
-        _("@foo")
-          .must_be_parsed_as s(:ivar, :@foo)
-      end
-
-      it "works for global variables" do
-        _("$foo")
-          .must_be_parsed_as s(:gvar, :$foo)
-      end
-
-      it "works for regexp match references" do
-        _("$1")
-          .must_be_parsed_as s(:nth_ref, 1)
-      end
-
-      specify { _("$'").must_be_parsed_as s(:back_ref, :"'") }
-      specify { _("$&").must_be_parsed_as s(:back_ref, :"&") }
-
-      it "works for class variables" do
-        _("@@foo")
-          .must_be_parsed_as s(:cvar, :@@foo)
-      end
-    end
-
-    describe "for expressions" do
-      it "handles assignment inside binary operator expressions" do
-        _("foo + (bar = baz)")
-          .must_be_parsed_as s(:call,
-                               s(:call, nil, :foo),
-                               :+,
-                               s(:lasgn,
-                                 :bar,
-                                 s(:call, nil, :baz)))
-      end
-
-      it "handles assignment inside unary operator expressions" do
-        _("+(foo = bar)")
-          .must_be_parsed_as s(:call,
-                               s(:lasgn, :foo, s(:call, nil, :bar)),
-                               :+@)
-      end
-    end
-
-    # Note: differences in the handling of comments are not caught by Sexp's
-    # implementation of equality.
-    describe "for comments" do
-      it "handles method comments" do
-        result = parser.parse "# Foo\ndef foo; end"
-        _(result).must_equal s(:defn,
-                               :foo,
-                               s(:args), s(:nil))
-        _(result.comments).must_equal "# Foo\n"
-      end
-
-      it "handles comments for methods with explicit receiver" do
-        result = parser.parse "# Foo\ndef foo.bar; end"
-        _(result).must_equal s(:defs,
-                               s(:call, nil, :foo),
-                               :bar,
-                               s(:args),
-                               s(:nil))
-        _(result.comments).must_equal "# Foo\n"
-      end
-
-      it "matches comments to the correct entity" do
-        result = parser.parse "# Foo\nclass Foo\n# Bar\ndef bar\nend\nend"
-        _(result).must_equal s(:class, :Foo, nil,
-                               s(:defn, :bar,
-                                 s(:args), s(:nil)))
-        _(result.comments).must_equal "# Foo\n"
-        defn = result[3]
-        _(defn.sexp_type).must_equal :defn
-        _(defn.comments).must_equal "# Bar\n"
-      end
-
-      it "combines multi-line comments" do
-        result = parser.parse "# Foo\n# Bar\ndef foo; end"
-        _(result).must_equal s(:defn,
-                               :foo,
-                               s(:args), s(:nil))
-        _(result.comments).must_equal "# Foo\n# Bar\n"
-      end
-
-      it "drops comments inside method bodies" do
-        result = parser.parse <<-RUBY
-          # Foo
-          class Foo
-            # foo
-            def foo
-              bar # this is dropped
-            end
-
-            # bar
-            def bar
-              baz
-            end
-          end
-        RUBY
-        _(result).must_equal s(:class,
-                               :Foo,
-                               nil,
-                               s(:defn, :foo, s(:args), s(:call, nil, :bar)),
-                               s(:defn, :bar, s(:args), s(:call, nil, :baz)))
-        _(result.comments).must_equal "# Foo\n"
-        _(result[3].comments).must_equal "# foo\n"
-        _(result[4].comments).must_equal "# bar\n"
-      end
-
-      it "handles the use of symbols that are keywords" do
-        result = parser.parse "# Foo\ndef bar\n:class\nend"
-        _(result).must_equal s(:defn,
-                               :bar,
-                               s(:args),
-                               s(:lit, :class))
-        _(result.comments).must_equal "# Foo\n"
-      end
-
-      it "handles use of singleton class inside methods" do
-        result = parser.parse "# Foo\ndef bar\nclass << self\nbaz\nend\nend"
-        _(result).must_equal s(:defn,
-                               :bar,
-                               s(:args),
-                               s(:sclass, s(:self),
-                                 s(:call, nil, :baz)))
-        _(result.comments).must_equal "# Foo\n"
-      end
-
-      # TODO: Prefer assigning comment to the BEGIN instead
-      it "assigns comments on BEGIN blocks to the following item" do
-        result = parser.parse "# Bar\nBEGIN { }\n# Foo\ndef foo; end"
-        _(result).must_equal s(:block,
-                               s(:iter, s(:preexe), 0),
-                               s(:defn, :foo, s(:args), s(:nil)))
-        _(result[2].comments).must_equal "# Bar\n# Foo\n"
-      end
-
-      it "assigns comments on multiple BEGIN blocks to the following item" do
-        result = parser.parse "# Bar\nBEGIN { }\n# Baz\nBEGIN { }\n# Foo\ndef foo; end"
-        _(result).must_equal s(:block,
-                               s(:iter, s(:preexe), 0),
-                               s(:iter, s(:preexe), 0),
-                               s(:defn, :foo, s(:args), s(:nil)))
-        _(result[3].comments).must_equal "# Bar\n# Baz\n# Foo\n"
-      end
-
-      it "assigns comments on BEGIN blocks to the first following item" do
-        result = parser.parse "# Bar\nBEGIN { }\n# Foo\nclass Bar\n# foo\ndef foo; end\nend"
-        _(result).must_equal s(:block,
-                               s(:iter, s(:preexe), 0),
-                               s(:class, :Bar, nil,
-                                 s(:defn, :foo, s(:args), s(:nil))))
-        _(result[2].comments).must_equal "# Bar\n# Foo\n"
-        _(result[2][3].comments).must_equal "# foo\n"
-      end
-    end
-
-    # Note: differences in the handling of line numbers are not caught by
-    # Sexp's implementation of equality.
-    describe "assigning line numbers" do
-      it "works for a plain method call" do
-        result = parser.parse "foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method call with parentheses" do
-        result = parser.parse "foo()"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method call with receiver" do
-        result = parser.parse "foo.bar"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method call with receiver and arguments" do
-        result = parser.parse "foo.bar baz"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method call with arguments" do
-        result = parser.parse "foo bar"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a block with two lines" do
-        result = parser.parse "foo\nbar\n"
-        _(result.sexp_type).must_equal :block
-        _(result[1].line).must_equal 1
-        _(result[2].line).must_equal 2
-        _(result.line).must_equal 1
-      end
-
-      it "works for a constant reference" do
-        result = parser.parse "Foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for an instance variable" do
-        result = parser.parse "@foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a global variable" do
-        result = parser.parse "$foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a class variable" do
-        result = parser.parse "@@foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a local variable" do
-        _("foo = bar\nfoo\n")
-          .must_be_parsed_as s(:block,
-                               s(:lasgn, :foo, s(:call, nil, :bar).line(1)).line(1),
-                               s(:lvar, :foo).line(2)).line(1),
-                             with_line_numbers: true
-      end
-
-      it "works for an integer literal" do
-        result = parser.parse "42"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a float literal" do
-        result = parser.parse "3.14"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a range literal" do
-        result = parser.parse "0..4"
-        _(result.line).must_equal 1
-      end
-
-      it "works for an exclusive range literal" do
-        result = parser.parse "0...4"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a symbol literal" do
-        result = parser.parse ":foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a keyword-like symbol literal" do
-        result = parser.parse ":and"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a string literal" do
-        result = parser.parse '"foo"'
-        _(result.line).must_equal 1
-      end
-
-      it "works for a backtick string literal" do
-        result = parser.parse "`foo`"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a plain regexp literal" do
-        result = parser.parse "/foo/"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a regular expression back reference" do
-        result = parser.parse "$1"
-        _(result.line).must_equal 1
-      end
-
-      it "works for self" do
-        result = parser.parse "self"
-        _(result.line).must_equal 1
-      end
-
-      it "works for __FILE__" do
-        result = parser.parse "__FILE__"
-        _(result.line).must_equal 1
-      end
-
-      it "works for nil" do
-        result = parser.parse "nil"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a symbol literal" do
-        result = parser.parse ":foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a class definition" do
-        result = parser.parse "class Foo; end"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a module definition" do
-        result = parser.parse "module Foo; end"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method definition" do
-        result = parser.parse "def foo; end"
-        _(result.line).must_equal 1
-      end
-
-      it "works for assignment of the empty hash" do
-        result = parser.parse "foo = {}"
-        _(result.line).must_equal 1
-      end
-
-      it "works for multiple assignment of empty hashes" do
-        result = parser.parse "foo, bar = {}, {}"
-        _(result.line).must_equal 1
-      end
-
-      it "assigns line numbers to nested sexps without their own line numbers" do
-        _("foo(bar) do\nnext baz\nend\n")
-          .must_be_parsed_as s(:iter,
-                               s(:call, nil, :foo, s(:call, nil, :bar).line(1)).line(1),
-                               0,
-                               s(:next, s(:call, nil, :baz).line(2)).line(2)).line(1),
-                             with_line_numbers: true
-      end
-
-      describe "when a line number is passed" do
-        it "shifts all line numbers as appropriate" do
-          result = parser.parse "foo\nbar\n", "(string)", 3
-          _(result).must_equal s(:block,
-                                 s(:call, nil, :foo),
-                                 s(:call, nil, :bar))
-          _(result.line).must_equal 3
-          _(result[1].line).must_equal 3
-          _(result[2].line).must_equal 4
-        end
-      end
-    end
-  end
-
-  describe "#trickle_up_line_numbers" do
-    it "works through several nested levels" do
-      inner = s(:foo)
-      outer = s(:bar, s(:baz, s(:qux, inner)))
-      outer.line = 42
-      parser.send :trickle_down_line_numbers, outer
-      _(inner.line).must_equal 42
-    end
-  end
-
-  describe "#trickle_down_line_numbers" do
-    it "works through several nested levels" do
-      inner = s(:foo)
-      inner.line = 42
-      outer = s(:bar, s(:baz, s(:qux, inner)))
-      parser.send :trickle_up_line_numbers, outer
-      _(outer.line).must_equal 42
-    end
-  end
-end