yard 0.8.7.6 → 0.9.0

data/spec/parser/ruby/ast_node_spec.rb

@@ -6,24 +6,24 @@ include YARD::Parser::Ruby
 
 describe YARD::Parser::Ruby::AstNode do
   describe "#jump" do
-    it "should jump to the first specific inner node if found" 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")))))
-      ast.jump(:params)[0][0].type.should equal(:ident)
+      expect(ast.jump(:params)[0][0].type).to equal(:ident)
     end
 
-    it "should return the original ast if no inner node is found" do
+    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")))))
-      ast.jump(:params).object_id.should == ast.object_id
+      expect(ast.jump(:params).object_id).to eq ast.object_id
     end
   end
 
-  describe '#pretty_print' do
-    it "should show a list of nodes" do
+  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'
-      out.string.should == "s(s(:#{vcall},\n" +
+      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" +

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

@@ -4,7 +4,7 @@ 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
+  it "parses dangling block expressions" do
     s = stmt <<-eof
       if
           foo
@@ -12,9 +12,9 @@ describe YARD::Parser::Ruby::Legacy::StatementList do
       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'"
+    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 ||
@@ -23,152 +23,152 @@ eof
       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'"
+    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 "should allow semicolons within parentheses" do
+  it "allows semicolons within parentheses" do
     s = stmt "(foo; bar)"
 
-    s.tokens.to_s(true).should == "(foo; bar)"
-    s.block.should be_nil
+    expect(s.tokens.to_s(true)).to eq "(foo; bar)"
+    expect(s.block).to be nil
   end
 
-  it "should allow for non-block statements" do
+  it "allows 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
+    expect(s.tokens.to_s).to eq "hello_world(1, 2, 3)"
+    expect(s.block).to be nil
   end
 
-  it "should allow block statements to be used as part of other block statements" do
+  it "allows 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"
+    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 "should allow continued processing after a block" do
+  it "allows 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 == ""
+    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]"
-    s.tokens.to_s(true).should == "if foo; end[stuff]"
-    s.block.to_s.should == ""
+    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"
-    s.tokens.to_s(true).should == "if foo; ... end.map do; 123; end"
-    s.block.to_s.should == "hi"
+    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 "should parse default arguments" do
+  it "parses 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"
+    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"
-    s.tokens.to_s(true).should == "def foo bar, baz = 1, bang = 2; ... end"
-    s.block.to_s.should == "bar"
+    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"
-    s.tokens.to_s(true).should == "def foo bar , baz = 1 , bang = 2; ... end"
-    s.block.to_s.should == "bar"
+    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 "should parse complex default arguments" do
+  it "parses 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"
+    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"
-    s.tokens.to_s(true).should == "def foo bar, baz = File.new(1, 2), bang = 3; ... end"
-    s.block.to_s.should == "bar"
+    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"
-    s.tokens.to_s(true).should == "def foo bar , baz = File.new(1, 2) , bang = 3; ... end"
-    s.block.to_s.should == "bar"
+    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 "should parse blocks with do/end" do
+  it "parses 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'"
+    expect(s.tokens.to_s(true)).to eq "foo do\n        ...\n      end"
+    expect(s.block.to_s).to eq "puts 'hi'"
   end
 
-  it "should parse blocks with {}" do
+  it "parses blocks with {}" do
     s = stmt "x { y }"
-    s.tokens.to_s(true).should == "x { ... }"
-    s.block.to_s.should == "y"
+    expect(s.tokens.to_s(true)).to eq "x { ... }"
+    expect(s.block.to_s).to eq "y"
 
     s = stmt "x() { y }"
-    s.tokens.to_s(true).should == "x() { ... }"
-    s.block.to_s.should == "y"
+    expect(s.tokens.to_s(true)).to eq "x() { ... }"
+    expect(s.block.to_s).to eq "y"
   end
 
-  it "should parse blocks with begin/end" do
+  it "parses blocks with begin/end" do
     s = stmt "begin xyz end"
-    s.tokens.to_s(true).should == "begin ... end"
-    s.block.to_s.should == "xyz"
+    expect(s.tokens.to_s(true)).to eq "begin ... end"
+    expect(s.block.to_s).to eq "xyz"
   end
 
-  it "should parse nested blocks" do
+  it "parses 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 }"
+    expect(s.tokens.to_s(true)).to eq "foo(:x) { ... }"
+    expect(s.block.to_s).to eq "baz(:y) { skippy }"
   end
 
-  it "should not parse hashes as blocks" do
+  it "does not parse hashes as blocks" do
     s = stmt "x({})"
-    s.tokens.to_s(true).should == "x({})"
-    s.block.to_s.should == ""
+    expect(s.tokens.to_s(true)).to eq "x({})"
+    expect(s.block.to_s).to eq ""
 
     s = stmt "x = {}"
-    s.tokens.to_s(true).should == "x = {}"
-    s.block.to_s.should == ""
+    expect(s.tokens.to_s(true)).to eq "x = {}"
+    expect(s.block.to_s).to eq ""
 
     s = stmt "x(y, {})"
-    s.tokens.to_s(true).should == "x(y, {})"
-    s.block.to_s.should == ""
+    expect(s.tokens.to_s(true)).to eq "x(y, {})"
+    expect(s.block.to_s).to eq ""
   end
 
-  it "should parse hashes in blocks with {}" do
+  it "parses hashes in blocks with {}" do
     s = stmt "x {x = {}}"
 
-    s.tokens.to_s(true).should == "x {...}"
-    s.block.to_s.should == "x = {}"
+    expect(s.tokens.to_s(true)).to eq "x {...}"
+    expect(s.block.to_s).to eq "x = {}"
   end
 
-  it "should parse blocks with {} in hashes" do
+  it "parses blocks with {} in hashes" do
     s = stmt "[:foo, x {}]"
 
-    s.tokens.to_s(true).should == "[:foo, x {}]"
-    s.block.to_s.should == ""
+    expect(s.tokens.to_s(true)).to eq "[:foo, x {}]"
+    expect(s.block.to_s).to eq ""
   end
 
-  it "should handle multiple methods" do
+  it "handles multiple methods" do
     s = stmt <<-eof
       def %; end
       def b; end
     eof
-    s.to_s.should == "def %; end"
+    expect(s.to_s).to eq "def %; end"
   end
 
-  it "should handle nested methods" do
+  it "handles 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"
+    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
@@ -176,18 +176,18 @@ eof
         def dynamic; end
       end
     eof
-    s[1].to_s.should == "def method1\n        def dynamic; end\n      end"
+    expect(s[1].to_s).to eq "def method1\n        def dynamic; end\n      end"
   end
 
-  it "should get comment line numbers" do
+  it "gets 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)
+    expect(s.comments).to eq ["comment", "comment", "comment"]
+    expect(s.comments_range).to eq (1..3)
 
     s = stmt <<-eof
 
@@ -195,8 +195,8 @@ eof
       # comment
       def method; end
     eof
-    s.comments.should == ["comment", "comment"]
-    s.comments_range.should == (2..3)
+    expect(s.comments).to eq ["comment", "comment"]
+    expect(s.comments_range).to eq (2..3)
 
     s = stmt <<-eof
       # comment
@@ -204,24 +204,24 @@ eof
 
       def method; end
     eof
-    s.comments.should == ["comment", "comment"]
-    s.comments_range.should == (1..2)
+    expect(s.comments).to eq ["comment", "comment"]
+    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 = stmt <<-eof
       # comments
 
@@ -229,7 +229,7 @@ eof
 
       def method; end
     eof
-    s.comments.should == ["comments"]
+    expect(s.comments).to eq ["comments"]
 
     s = stmt <<-eof
       # comments
@@ -237,7 +237,7 @@ eof
 
       def method; end
     eof
-    s.comments.should == nil
+    expect(s.comments).to eq nil
 
     ss = stmts <<-eof
       # comments
@@ -248,52 +248,52 @@ eof
       # hello
       def method2; end
     eof
-    ss[0].comments.should == nil
-    ss[1].comments.should == ['hello']
+    expect(ss[0].comments).to eq nil
+    expect(ss[1].comments).to eq ['hello']
   end
 
-  it "should handle CRLF (Windows) newlines" do
+  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")
-    s[1].comments.should == ['Test Test', '', 'Example:', '  example code']
+    expect(s[1].comments).to eq ['Test Test', '', 'Example:', '  example code']
   end
 
-  it "should handle elsif blocks" do
+  it "handles 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"
+    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 "should handle else blocks" do
+  it "handles 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"
+    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 "should allow aliasing keywords" do
+  it "allows 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
+      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")
-    s.tokens.to_s.should == "alias do x if 2 ==\n 2"
+    expect(s.tokens.to_s).to eq "alias do x if 2 ==\n 2"
   end
 
-  it "should not open a block on an aliased keyword block opener" do
+  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
-    s[0].block.to_s.should == 'alias x do'
-    s.size.should > 1
+    expect(s[0].block.to_s).to eq 'alias x do'
+    expect(s.size).to be > 1
   end
 
-  it "should convert heredoc to string" do
+  it "converts heredoc to string" do
     src = "<<-XML\n  foo\n\nXML"
     s = stmt(src)
-    s.source.should == '"foo\n\n"'
+    expect(s.source).to eq '"foo\n\n"'
   end
 end

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

@@ -5,45 +5,45 @@ 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
+    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
-      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
+      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 "should accept a string and parse it as code (via constructor or push)" do
-      lambda { TokenList.new("x = 2") }.should_not raise_error(ArgumentError)
+    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")
-      x.size.should == 6
-      x.to_s.should == "x\n=\n2\n"
+      expect(x.size).to eq 6
+      expect(x.to_s).to eq "x\n=\n2\n"
     end
 
-    it "should not accept any other input" do
-      lambda { TokenList.new(:notcode) }.should raise_error(ArgumentError)
+    it "does not accept any other input" do
+      expect { TokenList.new(:notcode) }.to raise_error(ArgumentError)
     end
 
-    it "should not interpolate string data" do
+    it "does 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"
+      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
+    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:'
+      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
+  describe "#to_s" do
     before do
       @t = TokenList.new
       @t << TkDEF.new(1, 1, "def")
@@ -62,16 +62,16 @@ describe YARD::Parser::Ruby::Legacy::TokenList do
       @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"
+    it "only shows the statement portion of the tokens by default" do
+      expect(@t.to_s).to eq "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"
+    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 "should ignore ... if show_block = false" do
-      @t.to_s(true, false).should == "def x;  end"
+    it "ignores ... if show_block = false" do
+      expect(@t.to_s(true, false)).to eq "def x;  end"
     end
   end
 end