etude_for_ruby 0.1.0 → 0.1.4

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/parser/examples/parse_in_order_001.rb.txt

@@ -0,0 +1,2 @@
+class MyModule::MyClass
+end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/parser/examples/parse_in_order_002.rb.txt

@@ -0,0 +1,2 @@
+module MyModule
+end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/parser/examples/tag_handler_001.rb.txt

@@ -0,0 +1,8 @@
+class Foo
+
+  # @api public
+  # @return nil
+  def foo
+  end
+
+end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/parser/ruby/ast_node_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'pp'
+require 'stringio'
+
+include YARD::Parser::Ruby
+
+RSpec.describe YARD::Parser::Ruby::AstNode do
+  describe "#jump" do
+    it "jumps to the first specific inner node if found" do
+      ast = s(:paren, s(:paren, s(:params, s(s(:ident, "hi"), s(:ident, "bye")))))
+      expect(ast.jump(:params)[0][0].type).to equal(:ident)
+    end
+
+    it "returns the original ast if no inner node is found" do
+      ast = s(:paren, s(:list, s(:list, s(s(:ident, "hi"), s(:ident, "bye")))))
+      expect(ast.jump(:params).object_id).to eq ast.object_id
+    end
+  end
+
+  describe "#pretty_print" do
+    it "shows a list of nodes" do
+      obj = YARD::Parser::Ruby::RubyParser.parse("# x\nbye", "x").ast
+      out = StringIO.new
+      PP.pp(obj, out)
+      vcall = RUBY_VERSION >= '1.9.3' ? 'vcall' : 'var_ref'
+      expect(out.string).to eq "s(s(:#{vcall},\n" \
+                               "      s(:ident, \"bye\", line: 2..2, source: 4..6),\n" \
+                               "      docstring: \"x\",\n" \
+                               "      line: 2..2,\n" \
+                               "      source: 4..6))\n"
+    end
+  end
+end if HAVE_RIPPER

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/parser/ruby/legacy/statement_list_spec.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+RSpec.describe YARD::Parser::Ruby::Legacy::StatementList do
+  def stmts(code) YARD::Parser::Ruby::Legacy::StatementList.new(code) end
+  def stmt(code) stmts(code).first end
+
+  it "parses dangling block expressions" do
+    s = stmt <<-eof
+      if
+          foo
+        puts 'hi'
+      end
+eof
+
+    expect(s.tokens.to_s(true)).to eq "if\n          foo\n        ...\n      end"
+    expect(s.tokens.to_s).to eq "if\n          foo"
+    expect(s.block.to_s).to eq "puts 'hi'"
+
+    s = stmt <<-eof
+      if foo ||
+          bar
+        puts 'hi'
+      end
+eof
+
+    expect(s.tokens.to_s(true)).to eq "if foo ||\n          bar\n        ...\n      end"
+    expect(s.tokens.to_s).to eq "if foo ||\n          bar"
+    expect(s.block.to_s).to eq "puts 'hi'"
+  end
+
+  it "allows semicolons within parentheses" do
+    s = stmt "(foo; bar)"
+
+    expect(s.tokens.to_s(true)).to eq "(foo; bar)"
+    expect(s.block).to be nil
+  end
+
+  it "allows for non-block statements" do
+    s = stmt "hello_world(1, 2, 3)"
+    expect(s.tokens.to_s).to eq "hello_world(1, 2, 3)"
+    expect(s.block).to be nil
+  end
+
+  it "allows block statements to be used as part of other block statements" do
+    s = stmt "while (foo; bar); foo = 12; end; while"
+
+    expect(s.tokens.to_s(true)).to eq "while (foo; bar); ... end"
+    expect(s.tokens.to_s).to eq "while (foo; bar)"
+    expect(s.block.to_s).to eq "foo = 12"
+  end
+
+  it "allows continued processing after a block" do
+    s = stmt "if foo; end.stuff"
+    expect(s.tokens.to_s(true)).to eq "if foo; end.stuff"
+    expect(s.block.to_s).to eq ""
+
+    s = stmt "if foo; end[stuff]"
+    expect(s.tokens.to_s(true)).to eq "if foo; end[stuff]"
+    expect(s.block.to_s).to eq ""
+
+    s = stmt "if foo; hi end.map do; 123; end"
+    expect(s.tokens.to_s(true)).to eq "if foo; ... end.map do; 123; end"
+    expect(s.block.to_s).to eq "hi"
+  end
+
+  it "parses default arguments" do
+    s = stmt "def foo(bar, baz = 1, bang = 2); bar; end"
+    expect(s.tokens.to_s(true)).to eq "def foo(bar, baz = 1, bang = 2) ... end"
+    expect(s.block.to_s).to eq "bar"
+
+    s = stmt "def foo bar, baz = 1, bang = 2; bar; end"
+    expect(s.tokens.to_s(true)).to eq "def foo bar, baz = 1, bang = 2; ... end"
+    expect(s.block.to_s).to eq "bar"
+
+    s = stmt "def foo bar , baz = 1 , bang = 2; bar; end"
+    expect(s.tokens.to_s(true)).to eq "def foo bar , baz = 1 , bang = 2; ... end"
+    expect(s.block.to_s).to eq "bar"
+  end
+
+  it "parses complex default arguments" do
+    s = stmt "def foo(bar, baz = File.new(1, 2), bang = 3); bar; end"
+    expect(s.tokens.to_s(true)).to eq "def foo(bar, baz = File.new(1, 2), bang = 3) ... end"
+    expect(s.block.to_s).to eq "bar"
+
+    s = stmt "def foo bar, baz = File.new(1, 2), bang = 3; bar; end"
+    expect(s.tokens.to_s(true)).to eq "def foo bar, baz = File.new(1, 2), bang = 3; ... end"
+    expect(s.block.to_s).to eq "bar"
+
+    s = stmt "def foo bar , baz = File.new(1, 2) , bang = 3; bar; end"
+    expect(s.tokens.to_s(true)).to eq "def foo bar , baz = File.new(1, 2) , bang = 3; ... end"
+    expect(s.block.to_s).to eq "bar"
+  end
+
+  it "parses blocks with do/end" do
+    s = stmt <<-eof
+      foo do
+        puts 'hi'
+      end
+    eof
+
+    expect(s.tokens.to_s(true)).to eq "foo do\n        ...\n      end"
+    expect(s.block.to_s).to eq "puts 'hi'"
+  end
+
+  it "parses blocks with {}" do
+    s = stmt "x { y }"
+    expect(s.tokens.to_s(true)).to eq "x { ... }"
+    expect(s.block.to_s).to eq "y"
+
+    s = stmt "x() { y }"
+    expect(s.tokens.to_s(true)).to eq "x() { ... }"
+    expect(s.block.to_s).to eq "y"
+  end
+
+  it "parses blocks with begin/end" do
+    s = stmt "begin xyz end"
+    expect(s.tokens.to_s(true)).to eq "begin ... end"
+    expect(s.block.to_s).to eq "xyz"
+  end
+
+  it "parses nested blocks" do
+    s = stmt "foo(:x) { baz(:y) { skippy } }"
+
+    expect(s.tokens.to_s(true)).to eq "foo(:x) { ... }"
+    expect(s.block.to_s).to eq "baz(:y) { skippy }"
+  end
+
+  it "does not parse hashes as blocks" do
+    s = stmt "x({})"
+    expect(s.tokens.to_s(true)).to eq "x({})"
+    expect(s.block.to_s).to eq ""
+
+    s = stmt "x = {}"
+    expect(s.tokens.to_s(true)).to eq "x = {}"
+    expect(s.block.to_s).to eq ""
+
+    s = stmt "x(y, {})"
+    expect(s.tokens.to_s(true)).to eq "x(y, {})"
+    expect(s.block.to_s).to eq ""
+  end
+
+  it "parses hashes in blocks with {}" do
+    s = stmt "x {x = {}}"
+
+    expect(s.tokens.to_s(true)).to eq "x {...}"
+    expect(s.block.to_s).to eq "x = {}"
+  end
+
+  it "parses blocks with {} in hashes" do
+    s = stmt "[:foo, x {}]"
+
+    expect(s.tokens.to_s(true)).to eq "[:foo, x {}]"
+    expect(s.block.to_s).to eq ""
+  end
+
+  it "handles multiple methods" do
+    s = stmt <<-eof
+      def %; end
+      def b; end
+    eof
+    expect(s.to_s).to eq "def %; end"
+  end
+
+  it "handles nested methods" do
+    s = stmt <<-eof
+      def *(o) def +@; end
+        def ~@
+        end end
+    eof
+    expect(s.tokens.to_s(true)).to eq "def *(o) ... end"
+    expect(s.block.to_s).to eq "def +@; end\n        def ~@\n        end"
+
+    s = stmts(<<-eof)
+      def /(other) 'hi' end
+      def method1
+        def dynamic; end
+      end
+    eof
+    expect(s[1].to_s).to eq "def method1\n        def dynamic; end\n      end"
+  end
+
+  it "gets comment line numbers" do
+    s = stmt <<-eof
+      # comment
+      # comment
+      # comment
+      def method; end
+    eof
+    expect(s.comments).to eq ["comment", "comment", "comment"]
+    expect(s.comments_range).to eq(1..3)
+
+    s = stmt <<-eof
+
+      # comment
+      # comment
+      def method; end
+    eof
+    expect(s.comments).to eq ["comment", "comment"]
+    expect(s.comments_range).to eq(2..3)
+
+    s = stmt <<-eof
+      # comment
+      # comment
+
+      def method; end
+    eof
+    expect(s.comments).to eq ["comment", "comment"]
+    expect(s.comments_range).to eq(1..2)
+
+    s = stmt <<-eof
+      # comment
+      def method; end
+    eof
+    expect(s.comments).to eq ["comment"]
+    expect(s.comments_range).to eq(1..1)
+
+    s = stmt <<-eof
+      def method; end # comment
+    eof
+    expect(s.comments).to eq ["comment"]
+    expect(s.comments_range).to eq(1..1)
+  end
+
+  it "only looks up to two lines back for comments" do
+    s = stmt <<-eof
+      # comments
+
+      # comments
+
+      def method; end
+    eof
+    expect(s.comments).to eq ["comments"]
+
+    s = stmt <<-eof
+      # comments
+
+
+      def method; end
+    eof
+    expect(s.comments).to eq nil
+
+    ss = stmts <<-eof
+      # comments
+
+
+      def method; end
+
+      # hello
+      def method2; end
+    eof
+    expect(ss[0].comments).to eq nil
+    expect(ss[1].comments).to eq ['hello']
+  end
+
+  it "handles CRLF (Windows) newlines" do
+    s = stmts("require 'foo'\r\n\r\n# Test Test\r\n# \r\n# Example:\r\n#   example code\r\ndef test\r\nend\r\n")
+    expect(s[1].comments).to eq ['Test Test', '', 'Example:', '  example code']
+  end
+
+  it "handles elsif blocks" do
+    s = stmts(stmt("if 0\n  foo\nelsif 2\n  bar\nend\nbaz").block)
+    expect(s.size).to eq 2
+    expect(s[1].tokens.to_s).to eq "elsif 2"
+    expect(s[1].block.to_s).to eq "bar"
+  end
+
+  it "handles else blocks" do
+    s = stmts(stmt("if 0\n  foo\nelse\n  bar\nend\nbaz").block)
+    expect(s.size).to eq 2
+    expect(s[1].tokens.to_s).to eq "else"
+    expect(s[1].block.to_s).to eq "bar"
+  end
+
+  it "allows aliasing keywords" do
+    ['do x', 'x do', 'end begin', 'begin end'].each do |a|
+      s = stmt("alias #{a}\ndef foo; end")
+      expect(s.tokens.to_s).to eq "alias #{a}"
+      expect(s.block).to be nil
+    end
+
+    s = stmt("alias do x if 2 ==\n 2")
+    expect(s.tokens.to_s).to eq "alias do x if 2 ==\n 2"
+  end
+
+  it "does not open a block on an aliased keyword block opener" do
+    s = stmts(<<-eof)
+      class A; alias x do end
+      class B; end
+    eof
+    expect(s[0].block.to_s).to eq 'alias x do'
+    expect(s.size).to be > 1
+  end
+
+  it "converts heredoc to string" do
+    src = "<<-XML\n  foo\n\nXML"
+    s = stmt(src)
+    expect(s.source).to eq '"foo\n\n"'
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/parser/ruby/legacy/token_list_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+include YARD::Parser::Ruby::Legacy
+include YARD::Parser::Ruby::Legacy::RubyToken
+
+RSpec.describe YARD::Parser::Ruby::Legacy::TokenList do
+  describe "#initialize / #push" do
+    it "accepts a tokenlist (via constructor or push)" do
+      expect { TokenList.new(TokenList.new) }.not_to raise_error
+      expect(TokenList.new.push(TokenList.new("x = 2")).size).to eq 6
+    end
+
+    it "accept a token (via constructor or push)" do
+      expect { TokenList.new(Token.new(0, 0)) }.not_to raise_error
+      expect(TokenList.new.push(Token.new(0, 0), Token.new(1, 1)).size).to eq 2
+    end
+
+    it "accepts a string and parse it as code (via constructor or push)" do
+      expect { TokenList.new("x = 2") }.not_to raise_error
+      x = TokenList.new
+      x.push("x", "=", "2")
+      expect(x.size).to eq 6
+      expect(x.to_s).to eq "x\n=\n2\n"
+    end
+
+    it "does not accept any other input" do
+      expect { TokenList.new(:notcode) }.to raise_error(ArgumentError)
+    end
+
+    it "does not interpolate string data" do
+      x = TokenList.new('x = "hello #{world}"')
+      expect(x.size).to eq 6
+      expect(x[4].class).to eq TkDSTRING
+      expect(x.to_s).to eq 'x = "hello #{world}"' + "\n"
+    end
+
+    it "handles label syntax" do
+      x = TokenList.new('a:1,b:2')
+      expect(x[0].class).to eq TkLABEL
+      expect(x[0].text).to eq 'a:'
+      expect(x[3].class).to eq TkLABEL
+      expect(x[3].text).to eq 'b:'
+    end
+  end
+
+  describe "#to_s" do
+    before do
+      @t = TokenList.new
+      @t << TkDEF.new(1, 1, "def")
+      @t << TkSPACE.new(1, 1)
+      @t << TkIDENTIFIER.new(1, 1, "x")
+      @t << TkStatementEnd.new(1, 1)
+      @t << TkSEMICOLON.new(1, 1) << TkSPACE.new(1, 1)
+      @t << TkBlockContents.new(1, 1)
+      @t << TkSPACE.new(1, 1) << TkEND.new(1, 1, "end")
+      @t[0].set_text "def"
+      @t[1].set_text " "
+      @t[2].set_text "x"
+      @t[4].set_text ";"
+      @t[5].set_text " "
+      @t[7].set_text " "
+      @t[8].set_text "end"
+    end
+
+    it "only shows the statement portion of the tokens by default" do
+      expect(@t.to_s).to eq "def x"
+    end
+
+    it "shows ... for the block token if all of the tokens are shown" do
+      expect(@t.to_s(true)).to eq "def x; ... end"
+    end
+
+    it "ignores ... if show_block = false" do
+      expect(@t.to_s(true, false)).to eq "def x;  end"
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/parser/ruby/ruby_parser_spec.rb

@@ -0,0 +1,481 @@
+# frozen_string_literal: true
+
+RSpec.describe YARD::Parser::Ruby::RubyParser do
+  def stmt(stmt)
+    YARD::Parser::Ruby::RubyParser.new(stmt, nil).parse.root.first
+  end
+
+  def stmts(stmts)
+    YARD::Parser::Ruby::RubyParser.new(stmts, nil).parse.root
+  end
+
+  def tokenize(stmt)
+    YARD::Parser::Ruby::RubyParser.new(stmt, nil).parse.tokens
+  end
+
+  describe "#parse" do
+    it "gets comment line numbers" do
+      s = stmt <<-eof
+        # comment
+        # comment
+        # comment
+        def method; end
+      eof
+      expect(s.comments).to eq "comment\ncomment\ncomment"
+      expect(s.comments_range).to eq(1..3)
+
+      s = stmt <<-eof
+
+        # comment
+        # comment
+        def method; end
+      eof
+      expect(s.comments).to eq "comment\ncomment"
+      expect(s.comments_range).to eq(2..3)
+
+      s = stmt <<-eof
+        # comment
+        # comment
+
+        def method; end
+      eof
+      expect(s.comments).to eq "comment\ncomment"
+      expect(s.comments_range).to eq(1..2)
+
+      s = stmt <<-eof
+        # comment
+        def method; end
+      eof
+      expect(s.comments).to eq "comment"
+      expect(s.comments_range).to eq(1..1)
+
+      s = stmt <<-eof
+        def method; end # comment
+      eof
+      expect(s.comments).to eq "comment"
+      expect(s.comments_range).to eq(1..1)
+    end
+
+    it "only looks up to two lines back for comments" do
+      s = stmts <<-eof
+        # comments
+
+        # comments
+
+        def method; end
+      eof
+      expect(s[1].comments).to eq "comments"
+
+      s = stmts <<-eof
+        # comments
+
+
+        def method; end
+      eof
+      expect(s[1].comments).to eq nil
+
+      ss = stmts <<-eof
+        # comments
+
+
+        def method; end
+
+        # hello
+        def method2; end
+      eof
+      expect(ss[1].comments).to eq nil
+      expect(ss[2].comments).to eq 'hello'
+    end
+
+    it "handles block comment followed by line comment" do
+      ss = stmts <<-eof
+# comments1
+
+=begin
+comments2
+=end
+# comments3
+def hello; end
+eof
+      expect(ss.last.comments).to eq "comments3"
+    end
+
+    it "handles block comment followed by block comment" do
+      ss = stmts <<-eof
+=begin
+comments1
+=end
+=begin
+comments2
+=end
+def hello; end
+eof
+      expect(ss.last.comments.strip).to eq "comments2"
+    end
+
+    it "handles 1.9 lambda syntax with args" do
+      src = "->(a,b,c=1,*args,&block) { hello_world }"
+      expect(stmt(src).source).to eq src
+    end
+
+    it "handles 1.9 lambda syntax" do
+      src = "-> { hello_world }"
+      expect(stmt(src).source).to eq src
+    end
+
+    it "handles standard lambda syntax" do
+      src = "lambda { hello_world }"
+      expect(stmt(src).source).to eq src
+    end
+
+    it "throws a ParserSyntaxError on invalid code" do
+      expect { stmt("Foo, bar.") }.to raise_error(YARD::Parser::ParserSyntaxError)
+    end
+
+    it "handles bare hashes as method parameters" do
+      src = "command :a => 1, :b => 2, :c => 3"
+      expect(stmt(src).jump(:command)[1].source).to eq ":a => 1, :b => 2, :c => 3"
+
+      src = "command a: 1, b: 2, c: 3"
+      expect(stmt(src).jump(:command)[1].source).to eq "a: 1, b: 2, c: 3"
+    end
+
+    it "handles source for hash syntax" do
+      src = "{ :a => 1, :b => 2, :c => 3 }"
+      expect(stmt(src).jump(:hash).source).to eq "{ :a => 1, :b => 2, :c => 3 }"
+    end
+
+    it "handles an empty hash" do
+      expect(stmt("{}").jump(:hash).source).to eq "{}"
+    end
+
+    it "new hash label syntax should show label without colon" do
+      ast = stmt("{ a: 1 }").jump(:label)
+      expect(ast[0]).to eq "a"
+      expect(ast.source).to eq "a:"
+    end
+
+    it "handles begin/rescue blocks" do
+      ast = stmt("begin; X; rescue => e; Y end").jump(:rescue)
+      expect(ast.source).to eq "rescue => e; Y end"
+
+      ast = stmt("begin; X; rescue A => e; Y end").jump(:rescue)
+      expect(ast.source).to eq "rescue A => e; Y end"
+
+      ast = stmt("begin; X; rescue A, B => e; Y end").jump(:rescue)
+      expect(ast.source).to eq "rescue A, B => e; Y end"
+    end
+
+    it "handles method rescue blocks" do
+      ast = stmt("def x; A; rescue Y; B end")
+      expect(ast.source).to eq "def x; A; rescue Y; B end"
+      expect(ast.jump(:rescue).source).to eq "rescue Y; B end"
+    end
+
+    it "handles defs with keywords as method name" do
+      ast = stmt("# docstring\nclass A;\ndef class; end\nend")
+      expect(ast.jump(:class).docstring).to eq "docstring"
+      expect(ast.jump(:class).line_range).to eq(2..4)
+    end
+
+    it "handles defs with unnamed argument with default values" do
+      ast = stmt('def hello(one, two = 2, three = 3) end').jump(:params)
+      expect(ast.source).to eq 'one, two = 2, three = 3'
+    end
+
+    it "handles defs with splats" do
+      ast = stmt('def hello(one, *two) end').jump(:params)
+      expect(ast.source).to eq 'one, *two'
+    end
+
+    if YARD.ruby2?
+      it "handles defs with named arguments with default values" do
+        ast = stmt('def hello(one, two: 2, three: 3) end').jump(:params)
+        expect(ast.source).to eq 'one, two: 2, three: 3'
+      end
+    end
+
+    if NAMED_OPTIONAL_ARGUMENTS
+      it "handles defs with named arguments without default values" do
+        ast = stmt('def hello(one, two:, three:) end').jump(:params)
+        expect(ast.source).to eq 'one, two:, three:'
+      end
+
+      it "handles defs with double splats" do
+        ast = stmt('def hello(one, **two) end').jump(:params)
+        expect(ast.source).to eq 'one, **two'
+      end
+    end
+
+    it "ends source properly on array reference" do
+      ast = stmt("AS[0, 1 ]   ")
+      expect(ast.source).to eq 'AS[0, 1 ]'
+
+      ast = stmt('def x(a = S[1]) end').jump(:params)
+      expect(ast.source).to eq 'a = S[1]'
+    end
+
+    it "ends source properly on if/unless mod" do
+      %w(if unless while).each do |mod|
+        expect(stmt("A=1 #{mod} true").source).to eq "A=1 #{mod} true"
+      end
+    end
+
+    it "shows proper source for assignment" do
+      expect(stmt("A=1").jump(:assign).source).to eq "A=1"
+    end
+
+    it "shows proper source for a top_const_ref" do
+      s = stmt("::\nFoo::Bar")
+      expect(s.jump(:top_const_ref).source).to eq "::\nFoo"
+      expect(s).to be_ref
+      expect(s.jump(:top_const_ref)).to be_ref
+      expect(s.source).to eq "::\nFoo::Bar"
+      expect(s.line_range.to_a).to eq [1, 2]
+    end
+
+    it "shows proper source for inline heredoc" do
+      src = "def foo\n  foo(<<-XML, 1, 2)\n    bar\n\n  XML\nend"
+      s = stmt(src)
+      t = tokenize(src)
+      expect(s.source).to eq src
+      expect(t.map {|x| x[1] }.join).to eq src
+    end
+
+    it "shows proper source for regular heredoc" do
+      src = "def foo\n  x = <<-XML\n  Hello \#{name}!\n  Bye!\n  XML\nend"
+      s = stmt(src)
+      t = tokenize(src)
+      expect(s.source).to eq src
+      expect(t.map {|x| x[1] }.join).to eq src
+    end
+
+    it "shows proper source for heredoc with comment" do
+      src = "def foo\n  x = <<-XML # HI!\n  Hello \#{name}!\n  Bye!\n  XML\nend"
+      s = stmt(src)
+      t = tokenize(src)
+      expect(s.source).to eq src
+      expect(t.map {|x| x[1] }.join).to eq src
+    end
+
+    it "shows proper source for string" do
+      ["'", '"'].each do |q|
+        src = "#{q}hello\n\nworld#{q}"
+        s = stmt(src)
+        expect(s.jump(:string_content).source).to eq "hello\n\nworld"
+        expect(s.source).to eq src
+      end
+
+      src = '("this is a string")'
+      expect(stmt(src).jump(:string_literal).source).to eq '"this is a string"'
+    end
+
+    %w(w W i I).each do |tok|
+      it "shows proper source for %#{tok}() array" do
+        src = "%#{tok}(\na b c\n d e f\n)"
+        expect(stmt(src).source).to eq src
+      end
+
+      it "shows proper source for %#{tok}{} array" do
+        src = "%#{tok}{\na b c\n d e f\n}"
+        expect(stmt(src).source).to eq src
+      end
+    end
+
+    {'i' => :qsymbols_literal, 'I' => :symbols_literal,
+     'w' => :qwords_literal, 'W' => :words_literal}.each do |id, sym|
+      it "parses %#{id}(...) literals" do
+        [
+          "TEST = %#{id}(A B C)",
+          "TEST = %#{id}(  A  B  C  )",
+          "TEST = %#{id}( \nA \nB \nC \n)",
+          "TEST = %#{id}(\n\nAD\n\nB\n\nC\n\n)",
+          "TEST = %#{id}(\n A\n B\n C\n )"
+        ].each do |str|
+          node = stmt(str).jump(sym)
+          expect(node.source).to eq(str[/(\%#{id}\(.+\))/m, 1])
+        end
+      end
+
+      it "tokenizing %#{id}(...) returns correct tokens" do
+        toks = tokenize("TEST = %#{id}(A B C)").flatten
+        expect(toks.count(:tstring_content)).to eq(3)
+      end
+    end
+
+    it "parses %w() array in constant declaration" do
+      s = stmt(<<-eof)
+        class Foo
+          FOO = %w( foo bar )
+        end
+      eof
+      expect(s.jump(:qwords_literal).source).to eq '%w( foo bar )'
+      if RUBY_VERSION >= '1.9.3' # ripper fix: array node encapsulates qwords
+        expect(s.jump(:array).source).to eq '%w( foo bar )'
+      end
+    end
+
+    it "parses %w() array source in object[] parsed context" do
+      s = stmts(<<-eof)
+        {}[:key]
+        FOO = %w( foo bar )
+      eof
+      expect(s[1].jump(:array).source).to eq '%w( foo bar )'
+    end
+
+    it "parses %w() array source in object[]= parsed context" do
+      s = stmts(<<-eof)
+        {}[:key] = :value
+        FOO = %w( foo bar )
+      eof
+      expect(s[1].jump(:array).source).to eq '%w( foo bar )'
+    end
+
+    it "parses [] as array" do
+      s = stmt(<<-eof)
+        class Foo
+          FOO = ['foo', 'bar']
+        end
+      eof
+      expect(s.jump(:array).source).to eq "['foo', 'bar']"
+    end
+
+    it "shows source for unary minus" do
+      expect(stmt("X = - 1").jump(:unary).source).to eq '- 1'
+    end
+
+    it "shows source for unary exclamation" do
+      expect(stmt("X = !1").jump(:unary).source).to eq '!1'
+    end
+
+    it "has the correct line range for class/modules" do
+      s = stmt(<<-eof)
+        class Foo
+          def foo; end
+
+
+
+          # Ending comment
+        end
+      eof
+      expect(s.jump(:class).line_range).to eq(1..7)
+    end
+
+    it "has the correct line range for blocks" do
+      Registry.clear
+      ast = YARD.parse_string(<<-eof).enumerator
+        module A
+          some_method
+        end
+      eof
+      expect(ast.first.block.source.strip).to eq "some_method"
+    end
+
+    it "finds lone comments" do
+      Registry.clear
+      ast = YARD.parse_string(<<-eof).enumerator
+        class Foo
+          ##
+          # comment here
+
+
+          def foo; end
+
+          # end comment
+        end
+      eof
+      comment = ast.first.last.jump(:comment)
+      expect(comment.type).to eq :comment
+      expect(comment.docstring_hash_flag).to be true
+      expect(comment.docstring.strip).to eq "comment here"
+
+      expect(ast.first.last.last.type).to eq :comment
+      expect(ast.first.last.last.docstring).to eq "end comment"
+    end
+
+    it "does not group comments if they don't begin the line" do
+      Registry.clear
+      YARD.parse_string(<<-eof).enumerator
+        class Foo
+          CONST1 = 1 # Comment here
+          CONST2 = 2 # Another comment here
+        end
+      eof
+      expect(Registry.at("Foo::CONST1").docstring).to eq "Comment here"
+      expect(Registry.at("Foo::CONST2").docstring).to eq "Another comment here"
+    end
+
+    %w(if unless).each do |type|
+      it "does not get confused by modifier '#{type}' statements" do
+        Registry.clear
+        YARD.parse_string(<<-eof).enumerator
+          module Foo
+            #{type} test?
+              # Docstring
+              class Bar
+                # Docstring2
+                def foo
+                  x #{type} true
+                end
+              end
+            end
+          end
+        eof
+
+        expect(Registry.at("Foo::Bar").docstring).to eq "Docstring"
+        expect(Registry.at("Foo::Bar#foo").docstring).to eq "Docstring2"
+      end
+
+      it "supports #{type} statements at start of source" do
+        Registry.clear
+        YARD.parse_string <<-eof
+          #{type} condition?
+            class Foo; def bar; #{type} true; end end end
+          end
+        eof
+
+        expect(log.io.string).to eq ""
+        expect(Registry.at('Foo#bar')).not_to eq nil
+      end
+
+      it "can handle complex non-modifier '#{type}' statements" do
+        Registry.clear
+        YARD.parse_string <<-eof
+          class Foo
+            def initialize(data, options = Hash.new)
+              #{type} true; raise "error" end
+              @x = ( #{type} 1; true end ) # This line should not blow up
+            end
+          end
+        eof
+
+        expect(log.io.string).to eq ""
+        expect(Registry.at('Foo#initialize')).not_to eq nil
+      end
+
+      it "does not add comment blocks to #{type}_mod nodes" do
+        Registry.clear
+        YARD.parse_string(<<-eof).enumerator
+          class Foo
+            # Docstring
+            def bar; end if true
+          end
+        eof
+
+        expect(Registry.at("Foo#bar").docstring).to eq "Docstring"
+      end
+    end
+
+    it "removes frozen string line from initial file comments" do
+      YARD.parse_string "# frozen_string_literal: true\n# this is a comment\nclass Foo; end"
+      YARD.parse_string "# Frozen-string-literal: true\n# this is a comment\nclass Bar; end"
+
+      expect(Registry.at(:Foo).docstring).to eq "this is a comment"
+      expect(Registry.at(:Bar).docstring).to eq "this is a comment"
+    end
+
+    it "handles compile errors" do
+      expect { stmt(":~$ Do not clobber") }.to raise_error(Parser::ParserSyntaxError)
+    end
+  end
+end if HAVE_RIPPER