deg-yard 0.8.7.1

data/spec/parser/ruby/legacy/statement_list_spec.rb

@@ -0,0 +1,299 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
+
+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 "should parse dangling block expressions" do
+    s = stmt <<-eof
+      if
+          foo
+        puts 'hi'
+      end
+eof
+
+    s.tokens.to_s(true).should == "if\n          foo\n        ...\n      end"
+    s.tokens.to_s.should == "if\n          foo"
+    s.block.to_s.should == "puts 'hi'"
+
+    s = stmt <<-eof
+      if foo ||
+          bar
+        puts 'hi'
+      end
+eof
+
+    s.tokens.to_s(true).should == "if foo ||\n          bar\n        ...\n      end"
+    s.tokens.to_s.should == "if foo ||\n          bar"
+    s.block.to_s.should == "puts 'hi'"
+  end
+
+  it "should allow semicolons within parentheses" do
+    s = stmt "(foo; bar)"
+
+    s.tokens.to_s(true).should == "(foo; bar)"
+    s.block.should be_nil
+  end
+
+  it "should allow for non-block statements" do
+    s = stmt "hello_world(1, 2, 3)"
+    s.tokens.to_s.should == "hello_world(1, 2, 3)"
+    s.block.should be_nil
+  end
+
+  it "should allow block statements to be used as part of other block statements" do
+    s = stmt "while (foo; bar); foo = 12; end; while"
+
+    s.tokens.to_s(true).should == "while (foo; bar); ... end"
+    s.tokens.to_s.should == "while (foo; bar)"
+    s.block.to_s.should == "foo = 12"
+  end
+
+  it "should allow continued processing after a block" do
+    s = stmt "if foo; end.stuff"
+    s.tokens.to_s(true).should == "if foo; end.stuff"
+    s.block.to_s.should == ""
+
+    s = stmt "if foo; end[stuff]"
+    s.tokens.to_s(true).should == "if foo; end[stuff]"
+    s.block.to_s.should == ""
+
+    s = stmt "if foo; hi end.map do; 123; end"
+    s.tokens.to_s(true).should == "if foo; ... end.map do; 123; end"
+    s.block.to_s.should == "hi"
+  end
+
+  it "should parse default arguments" do
+    s = stmt "def foo(bar, baz = 1, bang = 2); bar; end"
+    s.tokens.to_s(true).should == "def foo(bar, baz = 1, bang = 2) ... end"
+    s.block.to_s.should == "bar"
+
+    s = stmt "def foo bar, baz = 1, bang = 2; bar; end"
+    s.tokens.to_s(true).should == "def foo bar, baz = 1, bang = 2; ... end"
+    s.block.to_s.should == "bar"
+
+    s = stmt "def foo bar , baz = 1 , bang = 2; bar; end"
+    s.tokens.to_s(true).should == "def foo bar , baz = 1 , bang = 2; ... end"
+    s.block.to_s.should == "bar"
+  end
+
+  it "should parse complex default arguments" do
+    s = stmt "def foo(bar, baz = File.new(1, 2), bang = 3); bar; end"
+    s.tokens.to_s(true).should == "def foo(bar, baz = File.new(1, 2), bang = 3) ... end"
+    s.block.to_s.should == "bar"
+
+    s = stmt "def foo bar, baz = File.new(1, 2), bang = 3; bar; end"
+    s.tokens.to_s(true).should == "def foo bar, baz = File.new(1, 2), bang = 3; ... end"
+    s.block.to_s.should == "bar"
+
+    s = stmt "def foo bar , baz = File.new(1, 2) , bang = 3; bar; end"
+    s.tokens.to_s(true).should == "def foo bar , baz = File.new(1, 2) , bang = 3; ... end"
+    s.block.to_s.should == "bar"
+  end
+
+  it "should parse blocks with do/end" do
+    s = stmt <<-eof
+      foo do
+        puts 'hi'
+      end
+    eof
+
+    s.tokens.to_s(true).should == "foo do\n        ...\n      end"
+    s.block.to_s.should == "puts 'hi'"
+  end
+
+  it "should parse blocks with {}" do
+    s = stmt "x { y }"
+    s.tokens.to_s(true).should == "x { ... }"
+    s.block.to_s.should == "y"
+
+    s = stmt "x() { y }"
+    s.tokens.to_s(true).should == "x() { ... }"
+    s.block.to_s.should == "y"
+  end
+
+  it "should parse blocks with begin/end" do
+    s = stmt "begin xyz end"
+    s.tokens.to_s(true).should == "begin ... end"
+    s.block.to_s.should == "xyz"
+  end
+
+  it "should parse nested blocks" do
+    s = stmt "foo(:x) { baz(:y) { skippy } }"
+
+    s.tokens.to_s(true).should == "foo(:x) { ... }"
+    s.block.to_s.should == "baz(:y) { skippy }"
+  end
+
+  it "should not parse hashes as blocks" do
+    s = stmt "x({})"
+    s.tokens.to_s(true).should == "x({})"
+    s.block.to_s.should == ""
+
+    s = stmt "x = {}"
+    s.tokens.to_s(true).should == "x = {}"
+    s.block.to_s.should == ""
+
+    s = stmt "x(y, {})"
+    s.tokens.to_s(true).should == "x(y, {})"
+    s.block.to_s.should == ""
+  end
+
+  it "should parse hashes in blocks with {}" do
+    s = stmt "x {x = {}}"
+
+    s.tokens.to_s(true).should == "x {...}"
+    s.block.to_s.should == "x = {}"
+  end
+
+  it "should parse blocks with {} in hashes" do
+    s = stmt "[:foo, x {}]"
+
+    s.tokens.to_s(true).should == "[:foo, x {}]"
+    s.block.to_s.should == ""
+  end
+
+  it "should handle multiple methods" do
+    s = stmt <<-eof
+      def %; end
+      def b; end
+    eof
+    s.to_s.should == "def %; end"
+  end
+
+  it "should handle nested methods" do
+    s = stmt <<-eof
+      def *(o) def +@; end
+        def ~@
+        end end
+    eof
+    s.tokens.to_s(true).should == "def *(o) ... end"
+    s.block.to_s.should == "def +@; end\n        def ~@\n        end"
+
+    s = stmts(<<-eof)
+      def /(other) 'hi' end
+      def method1
+        def dynamic; end
+      end
+    eof
+    s[1].to_s.should == "def method1\n        def dynamic; end\n      end"
+  end
+
+  it "should get comment line numbers" do
+    s = stmt <<-eof
+      # comment
+      # comment
+      # comment
+      def method; end
+    eof
+    s.comments.should == ["comment", "comment", "comment"]
+    s.comments_range.should == (1..3)
+
+    s = stmt <<-eof
+
+      # comment
+      # comment
+      def method; end
+    eof
+    s.comments.should == ["comment", "comment"]
+    s.comments_range.should == (2..3)
+
+    s = stmt <<-eof
+      # comment
+      # comment
+
+      def method; end
+    eof
+    s.comments.should == ["comment", "comment"]
+    s.comments_range.should == (1..2)
+
+    s = stmt <<-eof
+      # comment
+      def method; end
+    eof
+    s.comments.should == ["comment"]
+    s.comments_range.should == (1..1)
+
+    s = stmt <<-eof
+      def method; end # comment
+    eof
+    s.comments.should == ["comment"]
+    s.comments_range.should == (1..1)
+  end
+
+  it "should only look up to two lines back for comments" do
+    s = stmt <<-eof
+      # comments
+
+      # comments
+
+      def method; end
+    eof
+    s.comments.should == ["comments"]
+
+    s = stmt <<-eof
+      # comments
+
+
+      def method; end
+    eof
+    s.comments.should == nil
+
+    ss = stmts <<-eof
+      # comments
+
+
+      def method; end
+
+      # hello
+      def method2; end
+    eof
+    ss[0].comments.should == nil
+    ss[1].comments.should == ['hello']
+  end
+
+  it "should handle 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")
+    s[1].comments.should == ['Test Test', '', 'Example:', '  example code']
+  end
+
+  it "should handle elsif blocks" do
+    s = stmts(stmt("if 0\n  foo\nelsif 2\n  bar\nend\nbaz").block)
+    s.size.should == 2
+    s[1].tokens.to_s.should == "elsif 2"
+    s[1].block.to_s.should == "bar"
+  end
+
+  it "should handle else blocks" do
+    s = stmts(stmt("if 0\n  foo\nelse\n  bar\nend\nbaz").block)
+    s.size.should == 2
+    s[1].tokens.to_s.should == "else"
+    s[1].block.to_s.should == "bar"
+  end
+
+  it "should allow aliasing keywords" do
+    ['do x', 'x do', 'end begin', 'begin end'].each do |a|
+      s = stmt("alias #{a}\ndef foo; end")
+      s.tokens.to_s.should == "alias #{a}"
+      s.block.should be_nil
+    end
+
+    s = stmt("alias do x if 2 ==\n 2")
+    s.tokens.to_s.should == "alias do x if 2 ==\n 2"
+  end
+
+  it "should not open a block on an aliased keyword block opener" do
+    s = stmts(<<-eof)
+      class A; alias x do end
+      class B; end
+    eof
+    s[0].block.to_s.should == 'alias x do'
+    s.size.should > 1
+  end
+
+  it "should convert heredoc to string" do
+    src = "<<-XML\n  foo\n\nXML"
+    s = stmt(src)
+    s.source.should == '"foo\n\n"'
+  end
+end

data/spec/parser/ruby/legacy/token_list_spec.rb

@@ -0,0 +1,77 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
+
+include YARD::Parser::Ruby::Legacy
+include YARD::Parser::Ruby::Legacy::RubyToken
+
+describe YARD::Parser::Ruby::Legacy::TokenList do
+  describe  "#initialize / #push" do
+    it "should accept a tokenlist (via constructor or push)" do
+      lambda { TokenList.new(TokenList.new) }.should_not raise_error(ArgumentError)
+      TokenList.new.push(TokenList.new("x = 2")).size.should == 6
+    end
+
+    it "accept a token (via constructor or push)" do
+      lambda { TokenList.new(Token.new(0, 0)) }.should_not raise_error(ArgumentError)
+      TokenList.new.push(Token.new(0, 0), Token.new(1, 1)).size.should == 2
+    end
+
+    it "should accept a string and parse it as code (via constructor or push)" do
+      lambda { TokenList.new("x = 2") }.should_not raise_error(ArgumentError)
+      x = TokenList.new
+      x.push("x", "=", "2")
+      x.size.should == 6
+      x.to_s.should == "x\n=\n2\n"
+    end
+
+    it "should not accept any other input" do
+      lambda { TokenList.new(:notcode) }.should raise_error(ArgumentError)
+    end
+
+    it "should not interpolate string data" do
+      x = TokenList.new('x = "hello #{world}"')
+      x.size.should == 6
+      x[4].class.should == TkDSTRING
+      x.to_s.should == 'x = "hello #{world}"' + "\n"
+    end
+
+    it 'handles label syntax' do
+      x = TokenList.new('a:1,b:2')
+      x[0].class.should == TkLABEL
+      x[0].text.should == 'a:'
+      x[3].class.should == TkLABEL
+      x[3].text.should == '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 "should only show the statement portion of the tokens by default" do
+      @t.to_s.should == "def x"
+    end
+
+    it "should show ... for the block token if all of the tokens are shown" do
+      @t.to_s(true).should == "def x; ... end"
+    end
+
+    it "should ignore ... if show_block = false" do
+      @t.to_s(true, false).should == "def x;  end"
+    end
+  end
+end

data/spec/parser/ruby/ruby_parser_spec.rb

@@ -0,0 +1,334 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+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 "should get comment line numbers" do
+      s = stmt <<-eof
+        # comment
+        # comment
+        # comment
+        def method; end
+      eof
+      s.comments.should == "comment\ncomment\ncomment"
+      s.comments_range.should == (1..3)
+
+      s = stmt <<-eof
+
+        # comment
+        # comment
+        def method; end
+      eof
+      s.comments.should == "comment\ncomment"
+      s.comments_range.should == (2..3)
+
+      s = stmt <<-eof
+        # comment
+        # comment
+
+        def method; end
+      eof
+      s.comments.should == "comment\ncomment"
+      s.comments_range.should == (1..2)
+
+      s = stmt <<-eof
+        # comment
+        def method; end
+      eof
+      s.comments.should == "comment"
+      s.comments_range.should == (1..1)
+
+      s = stmt <<-eof
+        def method; end # comment
+      eof
+      s.comments.should == "comment"
+      s.comments_range.should == (1..1)
+    end
+
+    it "should only look up to two lines back for comments" do
+      s = stmts <<-eof
+        # comments
+
+        # comments
+
+        def method; end
+      eof
+      s[1].comments.should == "comments"
+
+      s = stmts <<-eof
+        # comments
+
+
+        def method; end
+      eof
+      s[1].comments.should == nil
+
+      ss = stmts <<-eof
+        # comments
+
+
+        def method; end
+
+        # hello
+        def method2; end
+      eof
+      ss[1].comments.should == nil
+      ss[2].comments.should == 'hello'
+    end
+
+    it "should handle block comment followed by line comment" do
+      ss = stmts <<-eof
+# comments1
+
+=begin
+comments2
+=end
+# comments3
+def hello; end
+eof
+      ss.last.comments.should == "comments3"
+    end
+
+    it "should handle block comment followed by block comment" do
+      ss = stmts <<-eof
+=begin
+comments1
+=end
+=begin
+comments2
+=end
+def hello; end
+eof
+      ss.last.comments.strip.should == "comments2"
+    end
+
+    it "should handle 1.9 lambda syntax with args" do
+      src = "->(a,b,c=1,*args,&block) { hello_world }"
+      stmt(src).source.should == src
+    end
+
+    it "should handle 1.9 lambda syntax" do
+      src = "-> { hello_world }"
+      stmt(src).source.should == src
+    end
+
+    it "should handle standard lambda syntax" do
+      src = "lambda { hello_world }"
+      stmt(src).source.should == src
+    end
+
+    it "should throw a ParserSyntaxError on invalid code" do
+      lambda { stmt("Foo, bar.") }.should raise_error(YARD::Parser::ParserSyntaxError)
+    end
+
+    it "should handle bare hashes as method parameters" do
+      src = "command :a => 1, :b => 2, :c => 3"
+      stmt(src).jump(:command)[1].source.should == ":a => 1, :b => 2, :c => 3"
+
+      src = "command a: 1, b: 2, c: 3"
+      stmt(src).jump(:command)[1].source.should == "a: 1, b: 2, c: 3"
+    end
+
+    it "should handle source for hash syntax" do
+      src = "{ :a => 1, :b => 2, :c => 3 }"
+      stmt(src).jump(:hash).source.should == "{ :a => 1, :b => 2, :c => 3 }"
+    end
+
+    it "should handle an empty hash" do
+      stmt("{}").jump(:hash).source.should == "{}"
+    end
+
+    it "new hash label syntax should show label without colon" do
+      ast = stmt("{ a: 1 }").jump(:label)
+      ast[0].should == "a"
+      ast.source.should == "a:"
+    end
+
+    it "should handle begin/rescue blocks" do
+      ast = stmt("begin; X; rescue => e; Y end").jump(:rescue)
+      ast.source.should == "rescue => e; Y end"
+
+      ast = stmt("begin; X; rescue A => e; Y end").jump(:rescue)
+      ast.source.should == "rescue A => e; Y end"
+
+      ast = stmt("begin; X; rescue A, B => e; Y end").jump(:rescue)
+      ast.source.should == "rescue A, B => e; Y end"
+    end
+
+    it "should handle method rescue blocks" do
+      ast = stmt("def x; A; rescue Y; B end")
+      ast.source.should == "def x; A; rescue Y; B end"
+      ast.jump(:rescue).source.should == "rescue Y; B end"
+    end
+
+    it "should handle defs with keywords as method name" do
+      ast = stmt("# docstring\nclass A;\ndef class; end\nend")
+      ast.jump(:class).docstring.should == "docstring"
+      ast.jump(:class).line_range.should == (2..4)
+    end
+
+    it "should end source properly on array reference" do
+      ast = stmt("AS[0, 1 ]   ")
+      ast.source.should == 'AS[0, 1 ]'
+
+      ast = stmt("def x(a = S[1]) end").jump(:default_arg)
+      ast.source.should == 'a = S[1]'
+    end
+
+    it "should end source properly on if/unless mod" do
+      %w(if unless while).each do |mod|
+        stmt("A=1 #{mod} true").source.should == "A=1 #{mod} true"
+      end
+    end
+
+    it "should show proper source for assignment" do
+      stmt("A=1").jump(:assign).source.should == "A=1"
+    end
+
+    it "should show proper source for a top_const_ref" do
+      s = stmt("::\nFoo::Bar")
+      s.jump(:top_const_ref).source.should == "::\nFoo"
+      s.should be_ref
+      s.jump(:top_const_ref).should be_ref
+      s.source.should == "::\nFoo::Bar"
+      s.line_range.to_a.should == [1, 2]
+    end
+
+    it "should show 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)
+      s.source.should == src
+      t.map {|x| x[1] }.join.should == src
+    end
+
+    it "should show 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)
+      s.source.should == src
+      t.map {|x| x[1] }.join.should == src
+    end
+
+    it "should show 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)
+      s.source.should == src
+      t.map {|x| x[1] }.join.should == src
+    end
+
+    it "should show proper source for string" do
+      ["'", '"'].each do |q|
+        src = "#{q}hello\n\nworld#{q}"
+        s = stmt(src)
+        s.jump(:string_content).source.should == "hello\n\nworld"
+        s.source.should == src
+      end
+
+      src = '("this is a string")'
+      stmt(src).jump(:string_literal).source.should == '"this is a string"'
+    end
+
+    it "should show proper source for %w() array" do
+      src = "%w(\na b c\n d e f\n)"
+      stmt(src).jump(:qwords_literal).source.should == src
+    end
+
+    it "should show proper source for %w{} array" do
+      src = "%w{\na b c\n d e f\n}"
+      stmt(src).jump(:array).source.should == src
+    end
+
+    it "should parse %w() array in constant declaration" do
+      s = stmt(<<-eof)
+        class Foo
+          FOO = %w( foo bar )
+        end
+      eof
+      s.jump(:qwords_literal).source.should == '%w( foo bar )'
+      if RUBY_VERSION >= '1.9.3' # ripper fix: array node encapsulates qwords
+        s.jump(:array).source.should == '%w( foo bar )'
+      end
+    end
+
+    it "should parse %w() array source in object[] parsed context" do
+      s = stmts(<<-eof)
+        {}[:key]
+        FOO = %w( foo bar )
+      eof
+      s[1].jump(:array).source.should == '%w( foo bar )'
+    end
+
+    it "should parse %w() array source in object[]= parsed context" do
+      s = stmts(<<-eof)
+        {}[:key] = :value
+        FOO = %w( foo bar )
+      eof
+      s[1].jump(:array).source.should == '%w( foo bar )'
+    end
+
+    it "should parse [] as array" do
+      s = stmt(<<-eof)
+        class Foo
+          FOO = ['foo', 'bar']
+        end
+      eof
+      s.jump(:array).source.should == "['foo', 'bar']"
+    end
+
+    it "should show source for unary minus" do
+      stmt("X = - 1").jump(:unary).source.should == '- 1'
+    end
+
+    it "should show source for unary exclamation" do
+      stmt("X = !1").jump(:unary).source.should == '!1'
+    end
+
+    it "should have the correct line range for class/modules" do
+      s = stmt(<<-eof)
+        class Foo
+          def foo; end
+
+
+
+          # Ending comment
+        end
+      eof
+      s.jump(:class).line_range.should == (1..7)
+    end
+
+    it "should find 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.first
+      comment.type.should == :comment
+      comment.docstring_hash_flag.should be_true
+      comment.docstring.strip.should == "comment here"
+
+      ast.first.last.last.type.should == :comment
+      ast.first.last.last.docstring.should == "end comment"
+    end
+  end
+end if HAVE_RIPPER