yard 0.8.7.6 → 0.9.0

data/spec/code_objects/macro_object_spec.rb

@@ -5,144 +5,144 @@ describe YARD::CodeObjects::MacroObject do
     Registry.clear
   end
 
-  describe '.create' do
+  describe ".create" do
     def create(*args) MacroObject.create(*args) end
 
-    it "should create an object" do
+    it "creates an object" do
       create('foo', '')
       obj = Registry.at('.macro.foo')
-      obj.should_not be_nil
+      expect(obj).not_to be nil
     end
 
-    it "should use identity map" do
+    it "uses identity map" do
       obj1 = create('foo', '')
       obj2 = create('foo', '')
-      obj1.object_id.should == obj2.object_id
+      expect(obj1.object_id).to eq obj2.object_id
     end
 
-    it "should allow specifying of macro data" do
+    it "allows specifying of macro data" do
       obj = create('foo', 'MACRODATA')
-      obj.macro_data.should == 'MACRODATA'
+      expect(obj.macro_data).to eq 'MACRODATA'
     end
 
-    it "should attach if a method object is provided" do
-      obj = create('foo', 'MACRODATA', P('Foo.property'))
-      obj.method_object.should == P('Foo.property')
-      obj.should be_attached
+    context "if a method object is provided" do
+      it "attaches it" do
+        obj = create('foo', 'MACRODATA', P('Foo.property'))
+        expect(obj.method_object).to eq P('Foo.property')
+        expect(obj).to be_attached
+      end
     end
   end
 
-  describe '.find' do
+  describe ".find" do
     before { MacroObject.create('foo', 'DATA') }
 
-    it "should search for an object by name" do
-      MacroObject.find('foo').macro_data.should == 'DATA'
+    it "searches for an object by name" do
+      expect(MacroObject.find('foo').macro_data).to eq 'DATA'
     end
 
-    it "should accept Symbol" do
-      MacroObject.find(:foo).macro_data.should == 'DATA'
+    it "accepts Symbol" do
+      expect(MacroObject.find(:foo).macro_data).to eq 'DATA'
     end
   end
 
-  describe '.find_or_create' do
-    it "should look up name if @!macro is present and find object" do
+  describe ".find_or_create" do
+    it "looks up name if @!macro is present and find object" do
       macro1 = MacroObject.create('foo', 'FOO')
       macro2 = MacroObject.find_or_create('foo', "a b c")
-      macro1.should == macro2
+      expect(macro1).to eq macro2
     end
 
-    it "should create new macro if macro by that name does not exist" do
+    it "creates new macro if macro by that name does not exist" do
       MacroObject.find_or_create('foo', "@!method $1")
-      MacroObject.find('foo').macro_data.should == "@!method $1"
+      expect(MacroObject.find('foo').macro_data).to eq "@!method $1"
     end
   end
 
-  describe '.apply' do
-    before do
-      @args = %w(foo a b c)
-    end
+  describe ".apply" do
+    let(:args) { %w(foo a b c) }
 
     def apply(comments)
-      MacroObject.apply(comments, @args)
+      MacroObject.apply(comments, args)
     end
 
-    it "should only expand macros if @macro is present" do
-      apply("$1$2$3").should == "$1$2$3"
+    it "only expands macros if @macro is present" do
+      expect(apply("$1$2$3")).to eq "$1$2$3"
     end
 
-    it "should handle macro text inside block" do
-      apply("@!macro\n  foo$1$2$3\nfoobaz").should == "fooabc\nfoobaz"
+    it "handles macro text inside block" do
+      expect(apply("@!macro\n  foo$1$2$3\nfoobaz")).to eq "fooabc\nfoobaz"
     end
 
-    it "should append docstring to existing macro" do
+    it "appends docstring to existing macro" do
       macro = MacroObject.create('name', '$3$2$1')
-      result = MacroObject.apply("@!macro name\nfoobar", @args)
-      result.should == "cba\nfoobar"
+      result = MacroObject.apply("@!macro name\nfoobar", args)
+      expect(result).to eq "cba\nfoobar"
     end
 
-    it "should use only non macro data if docstring is an existing macro" do
+    it "uses only non-macro data if docstring is an existing macro" do
       data = "@!macro name\n  $3$2$1\nEXTRA"
-      result = MacroObject.apply(data, @args, 'SOURCE')
-      result.should == "cba\nEXTRA"
-      MacroObject.apply("@!macro name\nFOO", @args).should == "cba\nFOO"
+      result = MacroObject.apply(data, args, 'SOURCE')
+      expect(result).to eq "cba\nEXTRA"
+      expect(MacroObject.apply("@!macro name\nFOO", args)).to eq "cba\nFOO"
     end
 
-    it "should create macros if they don't exist" do
-      result = MacroObject.apply("@!macro name\n  foo!$1", @args, 'SOURCE')
-      result.should == "foo!a"
-      MacroObject.find('name').macro_data.should == 'foo!$1'
+    it "creates macros if they don't exist" do
+      result = MacroObject.apply("@!macro name\n  foo!$1", args, 'SOURCE')
+      expect(result).to eq "foo!a"
+      expect(MacroObject.find('name').macro_data).to eq 'foo!$1'
     end
 
-    it "should keep other tags" do
-      apply("@!macro\n  foo$1$2$3\n@param name foo\nfoo").should ==
-        "fooabc\nfoo\n@param name\n  foo"
+    it "keeps other tags" do
+      expect(apply("@!macro\n  foo$1$2$3\n@param name foo\nfoo")).to eq(
+        "fooabc\nfoo\n@param name\n  foo")
     end
   end
 
-  describe '.expand' do
+  describe ".expand" do
     def expand(comments)
       args = %w(foo a b c)
       full_line = 'foo :bar, :baz'
       MacroObject.expand(comments, args, full_line)
     end
 
-    it "should allow escaping of macro syntax" do
-      expand("$1\\$2$3").should == "a$2c"
+    it "allows escaping of macro syntax" do
+      expect(expand("$1\\$2$3")).to eq "a$2c"
     end
 
-    it "should replace $* with the whole statement" do
-      expand("$* ${*}").should == "foo :bar, :baz foo :bar, :baz"
+    it "replaces $* with the whole statement" do
+      expect(expand("$* ${*}")).to eq "foo :bar, :baz foo :bar, :baz"
     end
 
-    it "should replace $0 with method name" do
-      expand("$0 ${0}").should == "foo foo"
+    it "replaces $0 with method name" do
+      expect(expand("$0 ${0}")).to eq "foo foo"
     end
 
-    it "should replace all $N values with the Nth argument in the method call" do
-      expand("$1$2$3${3}\nfoobar").should == "abcc\nfoobar"
+    it "replaces all $N values with the Nth argument in the method call" do
+      expect(expand("$1$2$3${3}\nfoobar")).to eq "abcc\nfoobar"
     end
 
-    it "should replace ${N-M} ranges with N-M arguments (incl. commas)" do
-      expand("${1-2}x").should == "a, bx"
+    it "replaces ${N-M} ranges with N-M arguments (incl. commas)" do
+      expect(expand("${1-2}x")).to eq "a, bx"
     end
 
-    it "should handle open ended ranges (${N-})" do
-      expand("${2-}").should == "b, c"
+    it "handles open ended ranges (${N-})" do
+      expect(expand("${2-}")).to eq "b, c"
     end
 
-    it "should handle negative indexes ($-N)" do
-      expand("$-1 ${-2-} ${-2--2}").should == "c b, c b"
+    it "handles negative indexes ($-N)" do
+      expect(expand("$-1 ${-2-} ${-2--2}")).to eq "c b, c b"
     end
 
-    it "should accept Docstring objects" do
-      expand(Docstring.new("$1\n@param name foo")).should == "a\n@param name foo"
+    it "accepts Docstring objects" do
+      expect(expand(Docstring.new("$1\n@param name foo"))).to eq "a\n@param name foo"
     end
   end
 
-  describe '#expand' do
-    it "should expand macro given its data" do
+  describe "#expand" do
+    it "expands a macro given its data" do
       macro = MacroObject.create_docstring('foo', '$1 $2 THREE!')
-      macro.expand(['NAME', 'ONE', 'TWO']).should == "ONE TWO THREE!"
+      expect(macro.expand(['NAME', 'ONE', 'TWO'])).to eq "ONE TWO THREE!"
     end
   end
 end

data/spec/code_objects/method_object_spec.rb

@@ -6,170 +6,178 @@ describe YARD::CodeObjects::MethodObject do
     @yard = ModuleObject.new(:root, :YARD)
   end
 
-  it "should have a path of testing for an instance method in the root" do
-    meth = MethodObject.new(:root, :testing)
-    meth.path.should == "#testing"
+  context "for an instance method in the root" do
+    it "has a path of testing" do
+      meth = MethodObject.new(:root, :testing)
+      expect(meth.path).to eq "#testing"
+    end
   end
 
-  it "should have a path of YARD#testing for an instance method in YARD" do
-    meth = MethodObject.new(@yard, :testing)
-    meth.path.should == "YARD#testing"
+  context "for an instance method in YARD" do
+    it "has a path of YARD#testing" do
+      meth = MethodObject.new(@yard, :testing)
+      expect(meth.path).to eq "YARD#testing"
+    end
   end
 
-  it "should have a path of YARD.testing for a class method in YARD" do
-    meth = MethodObject.new(@yard, :testing, :class)
-    meth.path.should == "YARD.testing"
+  context "for a class method in YARD" do
+    it "has a path of YARD.testing" do
+      meth = MethodObject.new(@yard, :testing, :class)
+      expect(meth.path).to eq "YARD.testing"
+    end
   end
 
-  it "should have a path of ::testing (note the ::) for a class method added to root namespace" do
-    meth = MethodObject.new(:root, :testing, :class)
-    meth.path.should == "::testing"
+  context "for a class method added to root namespace" do
+    it "has a path of ::testing (note the ::)" do
+      meth = MethodObject.new(:root, :testing, :class)
+      expect(meth.path).to eq "::testing"
+    end
   end
 
-  it "should exist in the registry after successful creation" do
+  it "exists in the registry after successful creation" do
     obj = MethodObject.new(@yard, :something, :class)
-    Registry.at("YARD.something").should_not be_nil
-    Registry.at("YARD#something").should be_nil
-    Registry.at("YARD::something").should be_nil
+    expect(Registry.at("YARD.something")).not_to be nil
+    expect(Registry.at("YARD#something")).to be nil
+    expect(Registry.at("YARD::something")).to be nil
     obj = MethodObject.new(@yard, :somethingelse)
-    Registry.at("YARD#somethingelse").should_not be_nil
+    expect(Registry.at("YARD#somethingelse")).not_to be nil
   end
 
-  it "should allow #scope to be changed after creation" do
+  it "allows #scope to be changed after creation" do
     obj = MethodObject.new(@yard, :something, :class)
-    Registry.at("YARD.something").should_not be_nil
+    expect(Registry.at("YARD.something")).not_to be nil
     obj.scope = :instance
-    Registry.at("YARD.something").should be_nil
-    Registry.at("YARD#something").should_not be_nil
+    expect(Registry.at("YARD.something")).to be nil
+    expect(Registry.at("YARD#something")).not_to be nil
   end
 
-  it "should create object in :class scope if scope is :module" do
+  it "creates object in :class scope if scope is :module" do
     obj = MethodObject.new(@yard, :module_func, :module)
-    obj.scope.should == :class
-    obj.visibility.should == :public
-    Registry.at('YARD.module_func').should_not be_nil
+    expect(obj.scope).to eq :class
+    expect(obj.visibility).to eq :public
+    expect(Registry.at('YARD.module_func')).not_to be nil
   end
 
-  it "should create second private instance method if scope is :module" do
+  it "creates second private instance method if scope is :module" do
     MethodObject.new(@yard, :module_func, :module)
     obj = Registry.at('YARD#module_func')
-    obj.should_not be_nil
-    obj.visibility.should == :private
-    obj.scope.should == :instance
+    expect(obj).not_to be nil
+    expect(obj.visibility).to eq :private
+    expect(obj.scope).to eq :instance
   end
 
-  it "should yield block to second method if scope is :module" do
+  it "yields block to second method if scope is :module" do
     MethodObject.new(@yard, :module_func, :module) do |o|
       o.docstring = 'foo'
     end
-    Registry.at('YARD.module_func').docstring.should == 'foo'
-    Registry.at('YARD#module_func').docstring.should == 'foo'
+    expect(Registry.at('YARD.module_func').docstring).to eq 'foo'
+    expect(Registry.at('YARD#module_func').docstring).to eq 'foo'
   end
 
-  describe '#name' do
-    it "should show a prefix for an instance method when prefix=true" do
+  describe "#name" do
+    it "shows a prefix for an instance method when prefix=true" do
       obj = MethodObject.new(nil, :something)
-      obj.name(true).should == "#something"
+      expect(obj.name(true)).to eq "#something"
     end
 
-    it "should never show a prefix for a class method" do
+    it "never shows a prefix for a class method" do
       obj = MethodObject.new(nil, :something, :class)
-      obj.name.should == :"something"
-      obj.name(true).should == "something"
+      expect(obj.name).to eq :"something"
+      expect(obj.name(true)).to eq "something"
     end
   end
 
-  describe '#is_attribute?' do
-    it "should only return true if attribute is set in namespace for read/write" do
+  describe "#is_attribute?" do
+    it "only returns true if attribute is set in namespace for read/write" do
       obj = MethodObject.new(@yard, :foo)
       @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
-      obj.is_attribute?.should be_true
-      MethodObject.new(@yard, :foo=).is_attribute?.should be_false
+      expect(obj.is_attribute?).to be true
+      expect(MethodObject.new(@yard, :foo=).is_attribute?).to be false
     end
   end
 
-  describe '#attr_info' do
-    it "should return attribute info if namespace is available" do
+  describe "#attr_info" do
+    it "returns attribute info if namespace is available" do
       obj = MethodObject.new(@yard, :foo)
       @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
-      obj.attr_info.should == @yard.attributes[:instance][:foo]
+      expect(obj.attr_info).to eq @yard.attributes[:instance][:foo]
     end
 
-    it "should return nil if namespace is proxy" do
+    it "returns nil if namespace is proxy" do
       obj = MethodObject.new(P(:ProxyClass), :foo)
-      MethodObject.new(@yard, :foo).attr_info.should == nil
+      expect(MethodObject.new(@yard, :foo).attr_info).to eq nil
     end
 
-    it "should return nil if meth is not an attribute" do
-      MethodObject.new(@yard, :notanattribute).attr_info.should == nil
+    it "returns nil if meth is not an attribute" do
+      expect(MethodObject.new(@yard, :notanattribute).attr_info).to eq nil
     end
   end
 
-  describe '#writer?' do
-    it "should return true if method is a writer attribute" do
+  describe "#writer?" do
+    it "returns true if method is a writer attribute" do
       obj = MethodObject.new(@yard, :foo=)
       @yard.attributes[:instance][:foo] = {:read => nil, :write => obj}
-      obj.writer?.should == true
-      MethodObject.new(@yard, :NOTfoo=).writer?.should == false
+      expect(obj.writer?).to be true
+      expect(MethodObject.new(@yard, :NOTfoo=).writer?).to be false
     end
   end
 
-  describe '#reader?' do
-    it "should return true if method is a reader attribute" do
+  describe "#reader?" do
+    it "returns true if method is a reader attribute" do
       obj = MethodObject.new(@yard, :foo)
       @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
-      obj.reader?.should == true
-      MethodObject.new(@yard, :NOTfoo).reader?.should == false
+      expect(obj.reader?).to be true
+      expect(MethodObject.new(@yard, :NOTfoo).reader?).to be false
     end
   end
 
-  describe '#constructor?' do
+  describe "#constructor?" do
     before { @class = ClassObject.new(:root, :MyClass) }
 
-    it "should mark the #initialize method as constructor" do
+    it "marks the #initialize method as constructor" do
       MethodObject.new(@class, :initialize)
     end
 
-    it "should not mark Klass.initialize as constructor" do
-      MethodObject.new(@class, :initialize, :class).constructor?.should be_false
+    it "does not mark Klass.initialize as constructor" do
+      expect(MethodObject.new(@class, :initialize, :class).constructor?).to be false
     end
 
-    it "should not mark module method #initialize as constructor" do
-      MethodObject.new(@yard, :initialize).constructor?.should be_false
+    it "does not mark module method #initialize as constructor" do
+      expect(MethodObject.new(@yard, :initialize).constructor?).to be false
     end
   end
 
-  describe '#overridden_method' do
+  describe "#overridden_method" do
     before { Registry.clear }
 
-    it "should return overridden method from mixin first" do
+    it "returns overridden method from mixin first" do
       YARD.parse_string(<<-eof)
         module C; def foo; end end
         class A; def foo; end end
         class B < A; include C; def foo; end end
       eof
-      Registry.at('B#foo').overridden_method.should == Registry.at('C#foo')
+      expect(Registry.at('B#foo').overridden_method).to eq Registry.at('C#foo')
     end
 
-    it "should return overridden method from superclass" do
+    it "returns overridden method from superclass" do
       YARD.parse_string(<<-eof)
         class A; def foo; end end
         class B < A; def foo; end end
       eof
-      Registry.at('B#foo').overridden_method.should == Registry.at('A#foo')
+      expect(Registry.at('B#foo').overridden_method).to eq Registry.at('A#foo')
     end
 
-    it "should return nil if none is found" do
+    it "returns nil if none is found" do
       YARD.parse_string(<<-eof)
         class A; end
         class B < A; def foo; end end
       eof
-      Registry.at('B#foo').overridden_method.should be_nil
+      expect(Registry.at('B#foo').overridden_method).to be nil
     end
 
-    it "should return nil if namespace is a proxy" do
+    it "returns nil if namespace is a proxy" do
       YARD.parse_string "def ARGV.foo; end"
-      Registry.at('ARGV.foo').overridden_method.should be_nil
+      expect(Registry.at('ARGV.foo').overridden_method).to be nil
     end
   end
 end