yard 0.8.7.6 → 0.9.0

data/spec/parser/ruby/ruby_parser_spec.rb

@@ -13,16 +13,16 @@ describe YARD::Parser::Ruby::RubyParser do
     YARD::Parser::Ruby::RubyParser.new(stmt, nil).parse.tokens
   end
 
-  describe '#parse' do
-    it "should get comment line numbers" do
+  describe "#parse" do
+    it "gets 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)
+      expect(s.comments).to eq "comment\ncomment\ncomment"
+      expect(s.comments_range).to eq (1..3)
 
       s = stmt <<-eof
 
@@ -30,8 +30,8 @@ describe YARD::Parser::Ruby::RubyParser do
         # comment
         def method; end
       eof
-      s.comments.should == "comment\ncomment"
-      s.comments_range.should == (2..3)
+      expect(s.comments).to eq "comment\ncomment"
+      expect(s.comments_range).to eq (2..3)
 
       s = stmt <<-eof
         # comment
@@ -39,24 +39,24 @@ describe YARD::Parser::Ruby::RubyParser do
 
         def method; end
       eof
-      s.comments.should == "comment\ncomment"
-      s.comments_range.should == (1..2)
+      expect(s.comments).to eq "comment\ncomment"
+      expect(s.comments_range).to eq (1..2)
 
       s = stmt <<-eof
         # comment
         def method; end
       eof
-      s.comments.should == "comment"
-      s.comments_range.should == (1..1)
+      expect(s.comments).to eq "comment"
+      expect(s.comments_range).to eq (1..1)
 
       s = stmt <<-eof
         def method; end # comment
       eof
-      s.comments.should == "comment"
-      s.comments_range.should == (1..1)
+      expect(s.comments).to eq "comment"
+      expect(s.comments_range).to eq (1..1)
     end
 
-    it "should only look up to two lines back for comments" do
+    it "only looks up to two lines back for comments" do
       s = stmts <<-eof
         # comments
 
@@ -64,7 +64,7 @@ describe YARD::Parser::Ruby::RubyParser do
 
         def method; end
       eof
-      s[1].comments.should == "comments"
+      expect(s[1].comments).to eq "comments"
 
       s = stmts <<-eof
         # comments
@@ -72,7 +72,7 @@ describe YARD::Parser::Ruby::RubyParser do
 
         def method; end
       eof
-      s[1].comments.should == nil
+      expect(s[1].comments).to eq nil
 
       ss = stmts <<-eof
         # comments
@@ -83,11 +83,11 @@ describe YARD::Parser::Ruby::RubyParser do
         # hello
         def method2; end
       eof
-      ss[1].comments.should == nil
-      ss[2].comments.should == 'hello'
+      expect(ss[1].comments).to eq nil
+      expect(ss[2].comments).to eq 'hello'
     end
 
-    it "should handle block comment followed by line comment" do
+    it "handles block comment followed by line comment" do
       ss = stmts <<-eof
 # comments1
 
@@ -97,10 +97,10 @@ comments2
 # comments3
 def hello; end
 eof
-      ss.last.comments.should == "comments3"
+      expect(ss.last.comments).to eq "comments3"
     end
 
-    it "should handle block comment followed by block comment" do
+    it "handles block comment followed by block comment" do
       ss = stmts <<-eof
 =begin
 comments1
@@ -110,222 +110,222 @@ comments2
 =end
 def hello; end
 eof
-      ss.last.comments.strip.should == "comments2"
+      expect(ss.last.comments.strip).to eq "comments2"
     end
 
-    it "should handle 1.9 lambda syntax with args" do
+    it "handles 1.9 lambda syntax with args" do
       src = "->(a,b,c=1,*args,&block) { hello_world }"
-      stmt(src).source.should == src
+      expect(stmt(src).source).to eq src
     end
 
-    it "should handle 1.9 lambda syntax" do
+    it "handles 1.9 lambda syntax" do
       src = "-> { hello_world }"
-      stmt(src).source.should == src
+      expect(stmt(src).source).to eq src
     end
 
-    it "should handle standard lambda syntax" do
+    it "handles standard lambda syntax" do
       src = "lambda { hello_world }"
-      stmt(src).source.should == src
+      expect(stmt(src).source).to eq src
     end
 
-    it "should throw a ParserSyntaxError on invalid code" do
-      lambda { stmt("Foo, bar.") }.should raise_error(YARD::Parser::ParserSyntaxError)
+    it "throws a ParserSyntaxError on invalid code" do
+      expect { stmt("Foo, bar.") }.to raise_error(YARD::Parser::ParserSyntaxError)
     end
 
-    it "should handle bare hashes as method parameters" do
+    it "handles 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"
+      expect(stmt(src).jump(:command)[1].source).to eq ":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"
+      expect(stmt(src).jump(:command)[1].source).to eq "a: 1, b: 2, c: 3"
     end
 
-    it "should handle source for hash syntax" do
+    it "handles source for hash syntax" do
       src = "{ :a => 1, :b => 2, :c => 3 }"
-      stmt(src).jump(:hash).source.should == "{ :a => 1, :b => 2, :c => 3 }"
+      expect(stmt(src).jump(:hash).source).to eq "{ :a => 1, :b => 2, :c => 3 }"
     end
 
-    it "should handle an empty hash" do
-      stmt("{}").jump(:hash).source.should == "{}"
+    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)
-      ast[0].should == "a"
-      ast.source.should == "a:"
+      expect(ast[0]).to eq "a"
+      expect(ast.source).to eq "a:"
     end
 
-    it "should handle begin/rescue blocks" do
+    it "handles begin/rescue blocks" do
       ast = stmt("begin; X; rescue => e; Y end").jump(:rescue)
-      ast.source.should == "rescue => e; Y end"
+      expect(ast.source).to eq "rescue => e; Y end"
 
       ast = stmt("begin; X; rescue A => e; Y end").jump(:rescue)
-      ast.source.should == "rescue A => e; Y end"
+      expect(ast.source).to eq "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"
+      expect(ast.source).to eq "rescue A, B => e; Y end"
     end
 
-    it "should handle method rescue blocks" do
+    it "handles 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"
+      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 "should handle defs with keywords as method name" do
+    it "handles 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)
+      expect(ast.jump(:class).docstring).to eq "docstring"
+      expect(ast.jump(:class).line_range).to eq (2..4)
     end
 
-    it 'should handle defs with unnamed argument with default values' do
+    it "handles defs with unnamed argument with default values" do
       ast = stmt('def hello(one, two = 2, three = 3) end').jump(:params)
-      ast.source.should == 'one, two = 2, three = 3'
+      expect(ast.source).to eq 'one, two = 2, three = 3'
     end
 
-    it 'should handle defs with splats' do
+    it "handles defs with splats" do
       ast = stmt('def hello(one, *two) end').jump(:params)
-      ast.source.should == 'one, *two'
+      expect(ast.source).to eq 'one, *two'
     end
 
     if YARD.ruby2?
-      it 'should handle defs with named arguments with default values' do
+      it "handles defs with named arguments with default values" do
         ast = stmt('def hello(one, two: 2, three: 3) end').jump(:params)
-        ast.source.should == 'one, two: 2, three: 3'
+        expect(ast.source).to eq 'one, two: 2, three: 3'
       end
     end
 
     if NAMED_OPTIONAL_ARGUMENTS
-      it 'should handle defs with named arguments without default values' do
+      it "handles defs with named arguments without default values" do
         ast = stmt('def hello(one, two:, three:) end').jump(:params)
-        ast.source.should == 'one, two:, three:'
+        expect(ast.source).to eq 'one, two:, three:'
       end
 
-      it 'should handle defs with double splats' do
+      it "handles defs with double splats" do
         ast = stmt('def hello(one, **two) end').jump(:params)
-        ast.source.should == 'one, **two'
+        expect(ast.source).to eq 'one, **two'
       end
     end
 
-    it "should end source properly on array reference" do
+    it "ends source properly on array reference" do
       ast = stmt("AS[0, 1 ]   ")
-      ast.source.should == 'AS[0, 1 ]'
+      expect(ast.source).to eq 'AS[0, 1 ]'
 
       ast = stmt('def x(a = S[1]) end').jump(:params)
-      ast.source.should == 'a = S[1]'
+      expect(ast.source).to eq 'a = S[1]'
     end
 
-    it "should end source properly on if/unless mod" do
+    it "ends 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"
+        expect(stmt("A=1 #{mod} true").source).to eq "A=1 #{mod} true"
       end
     end
 
-    it "should show proper source for assignment" do
-      stmt("A=1").jump(:assign).source.should == "A=1"
+    it "shows proper source for assignment" do
+      expect(stmt("A=1").jump(:assign).source).to eq "A=1"
     end
 
-    it "should show proper source for a top_const_ref" do
+    it "shows 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]
+      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 "should show proper source for inline heredoc" do
+    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)
-      s.source.should == src
-      t.map {|x| x[1] }.join.should == src
+      expect(s.source).to eq src
+      expect(t.map { |x| x[1] }.join).to eq src
     end
 
-    it "should show proper source for regular heredoc" do
+    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)
-      s.source.should == src
-      t.map {|x| x[1] }.join.should == src
+      expect(s.source).to eq src
+      expect(t.map { |x| x[1] }.join).to eq src
     end
 
-    it "should show proper source for heredoc with comment" do
+    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)
-      s.source.should == src
-      t.map {|x| x[1] }.join.should == src
+      expect(s.source).to eq src
+      expect(t.map {|x| x[1] }.join).to eq src
     end
 
-    it "should show proper source for string" do
+    it "shows 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
+        expect(s.jump(:string_content).source).to eq "hello\n\nworld"
+        expect(s.source).to eq src
       end
 
       src = '("this is a string")'
-      stmt(src).jump(:string_literal).source.should == '"this is a string"'
+      expect(stmt(src).jump(:string_literal).source).to eq '"this is a string"'
     end
 
-    it "should show proper source for %w() array" do
+    it "shows proper source for %w() array" do
       src = "%w(\na b c\n d e f\n)"
-      stmt(src).jump(:qwords_literal).source.should == src
+      expect(stmt(src).jump(:qwords_literal).source).to eq src
     end
 
-    it "should show proper source for %w{} array" do
+    it "shows proper source for %w{} array" do
       src = "%w{\na b c\n d e f\n}"
-      stmt(src).jump(:array).source.should == src
+      expect(stmt(src).jump(:array).source).to eq src
     end
 
-    it "should parse %w() array in constant declaration" do
+    it "parses %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 )'
+      expect(s.jump(:qwords_literal).source).to eq '%w( foo bar )'
       if RUBY_VERSION >= '1.9.3' # ripper fix: array node encapsulates qwords
-        s.jump(:array).source.should == '%w( foo bar )'
+        expect(s.jump(:array).source).to eq '%w( foo bar )'
       end
     end
 
-    it "should parse %w() array source in object[] parsed context" do
+    it "parses %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 )'
+      expect(s[1].jump(:array).source).to eq '%w( foo bar )'
     end
 
-    it "should parse %w() array source in object[]= parsed context" do
+    it "parses %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 )'
+      expect(s[1].jump(:array).source).to eq '%w( foo bar )'
     end
 
-    it "should parse [] as array" do
+    it "parses [] as array" do
       s = stmt(<<-eof)
         class Foo
           FOO = ['foo', 'bar']
         end
       eof
-      s.jump(:array).source.should == "['foo', 'bar']"
+      expect(s.jump(:array).source).to eq "['foo', 'bar']"
     end
 
-    it "should show source for unary minus" do
-      stmt("X = - 1").jump(:unary).source.should == '- 1'
+    it "shows source for unary minus" do
+      expect(stmt("X = - 1").jump(:unary).source).to eq '- 1'
     end
 
-    it "should show source for unary exclamation" do
-      stmt("X = !1").jump(:unary).source.should == '!1'
+    it "shows source for unary exclamation" do
+      expect(stmt("X = !1").jump(:unary).source).to eq '!1'
     end
 
-    it "should have the correct line range for class/modules" do
+    it "has the correct line range for class/modules" do
       s = stmt(<<-eof)
         class Foo
           def foo; end
@@ -335,10 +335,20 @@ eof
           # Ending comment
         end
       eof
-      s.jump(:class).line_range.should == (1..7)
+      expect(s.jump(:class).line_range).to eq (1..7)
     end
 
-    it "should find lone comments" do
+    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
@@ -351,16 +361,16 @@ eof
           # 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"
+      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"
 
-      ast.first.last.last.type.should == :comment
-      ast.first.last.last.docstring.should == "end comment"
+      expect(ast.first.last.last.type).to eq :comment
+      expect(ast.first.last.last.docstring).to eq "end comment"
     end
 
-    it "should not group comments if they don't begin the line" do
+    it "does not group comments if they don't begin the line" do
       Registry.clear
       ast = YARD.parse_string(<<-eof).enumerator
         class Foo
@@ -368,8 +378,8 @@ eof
           CONST2 = 2 # Another comment here
         end
       eof
-      Registry.at("Foo::CONST1").docstring.should == "Comment here"
-      Registry.at("Foo::CONST2").docstring.should == "Another comment here"
+      expect(Registry.at("Foo::CONST1").docstring).to eq "Comment here"
+      expect(Registry.at("Foo::CONST2").docstring).to eq "Another comment here"
     end
   end
 end if HAVE_RIPPER