yard 0.8.7.6 → 0.9.0

data/spec/core_ext/module_spec.rb

@@ -1,15 +1,15 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Module do
-  describe '#class_name' do
-    it "should return just the name of the class/module" do
-      YARD::CodeObjects::Base.class_name.should == "Base"
+  describe "#class_name" do
+    it "returns just the name of the class/module" do
+      expect(YARD::CodeObjects::Base.class_name).to eq "Base"
     end
   end
 
-  describe '#namespace' do
-    it "should return everything before the class name" do
-      YARD::CodeObjects::Base.namespace_name.should == "YARD::CodeObjects"
+  describe "#namespace" do
+    it "returns everything before the class name" do
+      expect(YARD::CodeObjects::Base.namespace_name).to eq "YARD::CodeObjects"
     end
   end
 end

data/spec/core_ext/string_spec.rb

@@ -4,39 +4,39 @@ require File.dirname(__FILE__) + '/../spec_helper'
 #described_in_docs String, '#underscore'
 
 describe String do
-  describe '#shell_split' do
-    it "should split simple non-quoted text" do
-      "a b c".shell_split.should == %w(a b c)
+  describe "#shell_split" do
+    it "splits simple non-quoted text" do
+      expect("a b c".shell_split).to eq %w(a b c)
     end
 
-    it "should split double quoted text into single token" do
-      'a "b c d" e'.shell_split.should == ["a", "b c d", "e"]
+    it "splits double quoted text into single token" do
+      expect('a "b c d" e'.shell_split).to eq ["a", "b c d", "e"]
     end
 
-    it "should split single quoted text into single token" do
-      "a 'b c d' e".shell_split.should == ["a", "b c d", "e"]
+    it "splits single quoted text into single token" do
+      expect("a 'b c d' e".shell_split).to eq ["a", "b c d", "e"]
     end
 
-    it "should handle escaped quotations in quotes" do
-      "'a \\' b'".shell_split.should == ["a ' b"]
+    it "handles escaped quotations in quotes" do
+      expect("'a \\' b'".shell_split).to eq ["a ' b"]
     end
 
-    it "should handle escaped quotations outside quotes" do
-      "\\'a 'b'".shell_split.should == %w('a b)
+    it "handles escaped quotations outside quotes" do
+      expect("\\'a 'b'".shell_split).to eq %w('a b)
     end
 
-    it "should handle escaped backslash" do
-      "\\\\'a b c'".shell_split.should == ['\a b c']
+    it "handles escaped backslash" do
+      expect("\\\\'a b c'".shell_split).to eq ['\a b c']
     end
 
-    it "should handle any whitespace as space" do
+    it "handles any whitespace as space" do
       text = "foo\tbar\nbaz\r\nfoo2 bar2"
-      text.shell_split.should == %w(foo bar baz foo2 bar2)
+      expect(text.shell_split).to eq %w(foo bar baz foo2 bar2)
     end
 
-    it "should handle complex input" do
+    it "handles complex input" do
       text = "hello \\\"world \"1 2\\\" 3\" a 'b \"\\\\\\'' c"
-      text.shell_split.should == ["hello", "\"world", "1 2\" 3", "a", "b \"\\'", "c"]
+      expect(text.shell_split).to eq ["hello", "\"world", "1 2\" 3", "a", "b \"\\'", "c"]
     end
   end
 end

data/spec/core_ext/symbol_hash_spec.rb

@@ -1,86 +1,89 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe SymbolHash do
-
-  it "should allow access to keys as String or Symbol" do
+  it "allows access to keys as String or Symbol" do
     h = SymbolHash.new(false)
     h['test'] = true
-    h[:test].should == true
-    h['test'].should == true
+    expect(h[:test]).to be true
+    expect(h['test']).to be true
   end
 
-  it "should #delete by key as String or Symbol" do
-    h = SymbolHash.new
-    h.keys.length.should == 0
+  describe "#delete" do
+    it "accepts either Strings or Symbols as deletion key" do
+      h = SymbolHash.new
+      expect(h.keys.length).to eq 0
 
-    h['test'] = true
-    h.keys.length.should == 1
+      h['test'] = true
+      expect(h.keys.length).to eq 1
 
-    h.delete(:test)
-    h.keys.length.should == 0
+      h.delete(:test)
+      expect(h.keys.length).to eq 0
 
-    h[:test] = true
-    h.keys.length.should == 1
+      h[:test] = true
+      expect(h.keys.length).to eq 1
 
-    h.delete('test')
-    h.keys.length.should == 0
+      h.delete('test')
+      expect(h.keys.length).to eq 0
+    end
   end
 
-  it "should return same #has_key? for key as String or Symbol" do
-    h = SymbolHash.new
-    h[:test] = 1
-    h.has_key?(:test).should == true
-    h.has_key?('test').should == true
+  describe "#has_key?" do
+    it "returns same result for String or Symbol" do
+      h = SymbolHash.new
+      h[:test] = 1
+      expect(h.has_key?(:test)).to be true
+      expect(h.has_key?('test')).to be true
+    end
   end
 
-  it "should symbolize value if it is a String (and only a string)" do
+  it "symbolizes value if it is a String (and only a string)" do
     class Substring < String; end
 
     h = SymbolHash.new
     h['test1'] = "hello"
     h['test2'] = Substring.new("hello")
-    h['test1'].should == :hello
-    h['test2'].should == "hello"
+    expect(h['test1']).to eq :hello
+    expect(h['test2']).to eq "hello"
   end
 
-  it "should not symbolize value if SymbolHash.new(false) is created" do
+  it "does not symbolize value if SymbolHash.new(false) is created" do
     h = SymbolHash.new(false)
     h['test'] = "hello"
-    h[:test].should == "hello"
+    expect(h[:test]).to eq "hello"
   end
 
-  it "should not symbolize value if it is not a String" do
+  it "does not symbolize value if it is not a String" do
     h = SymbolHash.new
     h['test'] = [1,2,3]
-    h['test'].should == [1,2,3]
+    expect(h['test']).to eq [1,2,3]
   end
 
-  it "should support symbolization using #update or #merge!" do
+  it "supports symbolization using #update or #merge!" do
     h = SymbolHash.new
     h.update('test' => 'value')
-    h[:test].should == :value
+    expect(h[:test]).to eq :value
     h.merge!('test' => 'value2')
-    h[:test].should == :value2
+    expect(h[:test]).to eq :value2
   end
 
-  it "should support symbolization non-destructively using #merge" do
+  it "supports symbolization non-destructively using #merge" do
     h = SymbolHash.new
-    h.merge('test' => 'value')[:test].should == :value
-    h.should == SymbolHash.new
+    expect(h.merge('test' => 'value')[:test]).to eq :value
+    expect(h).to eq SymbolHash.new
   end
 
-  it "should support #initializing of a hash" do
+  it "supports #initializing of a hash" do
     h = SymbolHash[:test => 1]
-    h[:test].should == 1
-    h[:somethingelse].should be_nil
+    expect(h[:test]).to eq 1
+    expect(h[:somethingelse]).to be nil
   end
 
-  it "should support reverse merge syntax" do
+  it "supports reverse merge syntax" do
     opts = {}
     opts = SymbolHash[
       'default' => 1
     ].update(opts)
-    opts.keys.should == [:default]
-    opts[:default].should == 1
+    expect(opts.keys).to eq [:default]
+    expect(opts[:default]).to eq 1
   end
 end

data/spec/docstring_parser_spec.rb

@@ -16,8 +16,8 @@ describe YARD::DocstringParser do
     parse(content, object, handler).to_docstring
   end
 
-  describe '#parse' do
-    it "should parse comments into tags" do
+  describe "#parse" do
+    it "parses comments into tags" do
       doc = docstring(<<-eof)
 @param name Hello world
   how are you?
@@ -29,25 +29,25 @@ describe YARD::DocstringParser do
   right here.
       eof
       tags = doc.tags(:param)
-      tags[0].name.should == "name"
-      tags[0].text.should == "Hello world\nhow are you?"
-      tags[1].name.should == "name2"
-      tags[1].text.should == "this is a new line"
-      tags[2].name.should == "name3"
-      tags[2].text.should == "and this\nis a new paragraph:\n\nright here."
+      expect(tags[0].name).to eq "name"
+      expect(tags[0].text).to eq "Hello world\nhow are you?"
+      expect(tags[1].name).to eq "name2"
+      expect(tags[1].text).to eq "this is a new line"
+      expect(tags[2].name).to eq "name3"
+      expect(tags[2].text).to eq "and this\nis a new paragraph:\n\nright here."
     end
 
-    it "should end parsing a tag on de-dent" do
+    it "ends parsing a tag on de-dent" do
       doc = docstring(<<-eof)
 @note test
   one two three
 rest of docstring
       eof
-      doc.tag(:note).text.should == "test\none two three"
-      doc.should == "rest of docstring"
+      expect(doc.tag(:note).text).to eq "test\none two three"
+      expect(doc).to eq "rest of docstring"
     end
 
-    it "should parse examples embedded in doc" do
+    it "parses examples embedded in doc" do
       doc = docstring(<<-eof)
 test string here
 @example code
@@ -59,21 +59,21 @@ test string here
 
 more stuff
 eof
-      doc.should == "test string here\nmore stuff"
-      doc.tag(:example).text.should == "\ndef foo(x, y, z)\nend\n\nclass A; end"
+      expect(doc).to eq "test string here\nmore stuff"
+      expect(doc.tag(:example).text).to eq "\ndef foo(x, y, z)\nend\n\nclass A; end"
     end
 
-    it "should remove only original indentation from beginning of line in tags" do
+    it "removes only original indentation from beginning of line in tags" do
       doc = docstring(<<-eof)
 @param name
   some value
   foo bar
    baz
 eof
-      doc.tag(:param).text.should == "some value\nfoo bar\n baz"
+      expect(doc.tag(:param).text).to eq "some value\nfoo bar\n baz"
     end
 
-    it "should allow numbers in tags" do
+    it "allows numbers in tags" do
       Tags::Library.define_tag(nil, :foo1)
       Tags::Library.define_tag(nil, :foo2)
       Tags::Library.define_tag(nil, :foo3)
@@ -82,142 +82,142 @@ eof
 @foo2 bar2
 @foo3 bar3
 eof
-      doc.tag(:foo1).text.should == "bar1"
-      doc.tag(:foo2).text.should == "bar2"
+      expect(doc.tag(:foo1).text).to eq "bar1"
+      expect(doc.tag(:foo2).text).to eq "bar2"
     end
 
-    it "should end tag on newline if next line is not indented" do
+    it "ends tag on newline if next line is not indented" do
       doc = docstring(<<-eof)
 @author bar1
 @api bar2
 Hello world
 eof
-      doc.tag(:author).text.should == "bar1"
-      doc.tag(:api).text.should == "bar2"
+      expect(doc.tag(:author).text).to eq "bar1"
+      expect(doc.tag(:api).text).to eq "bar2"
     end
 
-    it "should warn about unknown tag" do
-      log.should_receive(:warn).with(/Unknown tag @hello$/)
+    it "warns about unknown tag" do
+      expect(log).to receive(:warn).with(/Unknown tag @hello$/)
       docstring("@hello world")
     end
 
-    it "should not add trailing whitespace to freeform tags" do
+    it "does not add trailing whitespace to freeform tags" do
       doc = docstring("@api private   \t   ")
-      doc.tag(:api).text.should == "private"
+      expect(doc.tag(:api).text).to eq "private"
     end
   end
 
-  describe '#parse with custom tag library' do
+  describe "#parse with custom tag library" do
     class TestLibrary < Tags::Library; end
 
     before { @library = TestLibrary.new }
 
-    it "should accept valid tags" do
+    it "accepts valid tags" do
       valid = %w( testing valid is_a is_A __ )
       valid.each do |tag|
         TestLibrary.define_tag("Tag", tag)
         doc = docstring('@' + tag + ' foo bar')
-        doc.tag(tag).text.should == 'foo bar'
+        expect(doc.tag(tag).text).to eq 'foo bar'
       end
     end
 
-    it "should not parse invalid tag names" do
+    it "does not parse invalid tag names" do
       invalid = %w( @ @return@ @param, @x-y @.x.y.z )
       invalid.each do |tag|
-        docstring(tag + ' foo bar').should == tag + ' foo bar'
+        expect(docstring(tag + ' foo bar')).to eq tag + ' foo bar'
       end
     end
 
-    it "should allow namespaced tags in the form @x.y.z" do
+    it "allows namespaced tags in the form @x.y.z" do
       TestLibrary.define_tag("Tag", 'x.y.z')
       doc = docstring("@x.y.z foo bar")
-      doc.tag('x.y.z').text.should == 'foo bar'
+      expect(doc.tag('x.y.z').text).to eq 'foo bar'
     end
 
-    it "should ignore new directives without @! prefix syntax" do
+    it "ignores new directives without @! prefix syntax" do
       TestLibrary.define_directive('dir1', Tags::ScopeDirective)
-      log.should_receive(:warn).with(/@dir1/)
+      expect(log).to receive(:warn).with(/@dir1/)
       docstring("@dir1")
     end
 
     %w(attribute endgroup group macro method scope visibility).each do |tag|
-      it "should handle non prefixed @#{tag} syntax as directive, not tag" do
+      it "handles non prefixed @#{tag} syntax as directive, not tag" do
         TestLibrary.define_directive(tag, Tags::ScopeDirective)
         parse("@#{tag}")
-        @parser.directives.first.should be_a(Tags::ScopeDirective)
+        expect(@parser.directives.first).to be_a(Tags::ScopeDirective)
       end
     end
 
-    it "should handle directives with @! prefix syntax" do
+    it "handles directives with @! prefix syntax" do
       TestLibrary.define_directive('dir1', Tags::ScopeDirective)
       docstring("@!dir1 class")
-      @parser.state.scope.should == :class
+      expect(@parser.state.scope).to eq :class
     end
   end
 
-  describe '#text' do
-    it "should only return text data" do
+  describe "#text" do
+    it "only returns text data" do
       parse("Foo\n@param foo x y z\nBar")
-      @parser.text.should == "Foo\nBar"
+      expect(@parser.text).to eq "Foo\nBar"
     end
   end
 
-  describe '#raw_text' do
-    it "should return the entire original data" do
+  describe "#raw_text" do
+    it "returns the entire original data" do
       data = "Foo\n@param foo x y z\nBar"
       parse(data)
-      @parser.raw_text.should == data
+      expect(@parser.raw_text).to eq data
     end
   end
 
-  describe '#tags' do
-    it "should return the parsed tags" do
+  describe "#tags" do
+    it "returns the parsed tags" do
       data = "Foo\n@param foo x y z\nBar"
       parse(data)
-      @parser.tags.size.should == 1
-      @parser.tags.first.tag_name.should == 'param'
+      expect(@parser.tags.size).to eq 1
+      expect(@parser.tags.first.tag_name).to eq 'param'
     end
   end
 
-  describe '#directives' do
-    it "should group all processed directives" do
+  describe "#directives" do
+    it "groups all processed directives" do
       data = "Foo\n@!scope class\n@!visibility private\nBar"
       parse(data)
       dirs = @parser.directives
       dirs.size == 2
-      dirs[0].should be_a(Tags::ScopeDirective)
-      dirs[0].tag.text.should == 'class'
-      dirs[1].should be_a(Tags::VisibilityDirective)
-      dirs[1].tag.text.should == 'private'
+      expect(dirs[0]).to be_a(Tags::ScopeDirective)
+      expect(dirs[0].tag.text).to eq 'class'
+      expect(dirs[1]).to be_a(Tags::VisibilityDirective)
+      expect(dirs[1].tag.text).to eq 'private'
     end
   end
 
-  describe '#state' do
-    it "should handle modified state" do
+  describe "#state" do
+    it "handles modified state" do
       parse("@!scope class")
-      @parser.state.scope.should == :class
+      expect(@parser.state.scope).to eq :class
     end
   end
 
-  describe 'after_parse' do
-    it "should allow specifying of callbacks" do
+  describe "after_parse" do
+    it "allows specifying of callbacks" do
       parser = DocstringParser.new
       the_yielded_obj = nil
       DocstringParser.after_parse {|obj| the_yielded_obj = obj }
       parser.parse("Some text")
-      the_yielded_obj.should == parser
+      expect(the_yielded_obj).to eq parser
     end
 
-    it "should warn about invalid named parameters" do
-      log.should_receive(:warn).with(/@param tag has unknown parameter name: notaparam/)
+    it "warns about invalid named parameters" do
+      expect(log).to receive(:warn).with(/@param tag has unknown parameter name: notaparam/)
       YARD.parse_string <<-eof
         # @param notaparam foo
         def foo(a) end
       eof
     end
 
-    it "should warn about duplicate named parameters" do
-      log.should_receive(:warn).with(/@param tag has duplicate parameter name: a/)
+    it "warns about duplicate named parameters" do
+      expect(log).to receive(:warn).with(/@param tag has duplicate parameter name: a/)
       YARD.parse_string <<-eof
         # @param a foo
         # @param a foo