yard 0.8.7.6 → 0.9.0

data/spec/code_objects/module_object_spec.rb

@@ -37,65 +37,65 @@ describe YARD::CodeObjects::ModuleObject do
       @yard.class_mixins << @another
     end
 
-    it "should list all methods (including mixin methods) via #meths" do
+    it "lists all methods (including mixin methods) via #meths" do
       meths = @yard.meths
-      meths.should include(P("YARD#foo"))
-      meths.should include(P("YARD#foo2"))
-      meths.should include(P("YARD.bar"))
-      meths.should include(P("SomeMod#mixmethod"))
-      meths.should include(P("AnotherMod#fizz"))
+      expect(meths).to include(P("YARD#foo"))
+      expect(meths).to include(P("YARD#foo2"))
+      expect(meths).to include(P("YARD.bar"))
+      expect(meths).to include(P("SomeMod#mixmethod"))
+      expect(meths).to include(P("AnotherMod#fizz"))
     end
 
-    it "should allow :visibility to be set" do
+    it "allows :visibility to be set" do
       meths = @yard.meths(:visibility => :public)
-      meths.should_not include(P("YARD.bar"))
+      expect(meths).not_to include(P("YARD.bar"))
       meths = @yard.meths(:visibility => [:public, :private])
-      meths.should include(P("YARD#foo"))
-      meths.should include(P("YARD.bar"))
-      meths.should_not include(P("YARD#foo2"))
+      expect(meths).to include(P("YARD#foo"))
+      expect(meths).to include(P("YARD.bar"))
+      expect(meths).not_to include(P("YARD#foo2"))
     end
 
-    it "should only display class methods for :scope => :class" do
+    it "only displays class methods for :scope => :class" do
       meths = @yard.meths(:scope => :class)
-      meths.should_not include(P("YARD#foo"))
-      meths.should_not include(P("YARD#foo2"))
-      meths.should_not include(P("SomeMod#mixmethod"))
-      meths.should_not include(P("SomeMod.baz"))
-      meths.should_not include(P("AnotherMod#fazz"))
-      meths.should include(P("YARD.bar"))
-      meths.should include(P("AnotherMod#fizz"))
+      expect(meths).not_to include(P("YARD#foo"))
+      expect(meths).not_to include(P("YARD#foo2"))
+      expect(meths).not_to include(P("SomeMod#mixmethod"))
+      expect(meths).not_to include(P("SomeMod.baz"))
+      expect(meths).not_to include(P("AnotherMod#fazz"))
+      expect(meths).to include(P("YARD.bar"))
+      expect(meths).to include(P("AnotherMod#fizz"))
     end
 
-    it "should only display instance methods for :scope => :class" do
+    it "only displays instance methods for :scope => :class" do
       meths = @yard.meths(:scope => :instance)
-      meths.should include(P("YARD#foo"))
-      meths.should include(P("YARD#foo2"))
-      meths.should include(P("SomeMod#mixmethod"))
-      meths.should_not include(P("YARD.bar"))
-      meths.should_not include(P("AnotherMod#fizz"))
+      expect(meths).to include(P("YARD#foo"))
+      expect(meths).to include(P("YARD#foo2"))
+      expect(meths).to include(P("SomeMod#mixmethod"))
+      expect(meths).not_to include(P("YARD.bar"))
+      expect(meths).not_to include(P("AnotherMod#fizz"))
     end
 
-    it "should allow :included to be set" do
+    it "allows :included to be set" do
       meths = @yard.meths(:included => false)
-      meths.should_not include(P("SomeMod#mixmethod"))
-      meths.should_not include(P("AnotherMod#fizz"))
-      meths.should include(P("YARD#foo"))
-      meths.should include(P("YARD#foo2"))
-      meths.should include(P("YARD.bar"))
+      expect(meths).not_to include(P("SomeMod#mixmethod"))
+      expect(meths).not_to include(P("AnotherMod#fizz"))
+      expect(meths).to include(P("YARD#foo"))
+      expect(meths).to include(P("YARD#foo2"))
+      expect(meths).to include(P("YARD.bar"))
     end
 
-    it "should choose the method defined in the class over an included module" do
+    it "chooses the method defined in the class over an included module" do
       meths = @yard.meths
-      meths.should_not include(P("SomeMod#xyz"))
-      meths.should include(P("YARD#xyz"))
-      meths.should_not include(P("AnotherMod#bar"))
-      meths.should include(P("YARD.bar"))
+      expect(meths).not_to include(P("SomeMod#xyz"))
+      expect(meths).to include(P("YARD#xyz"))
+      expect(meths).not_to include(P("AnotherMod#bar"))
+      expect(meths).to include(P("YARD.bar"))
 
       meths = @other.meths
-      meths.should include(P("SomeMod#xyz"))
+      expect(meths).to include(P("SomeMod#xyz"))
 
       meths = @another.meths
-      meths.should include(P("AnotherMod#bar"))
+      expect(meths).to include(P("AnotherMod#bar"))
     end
   end
 
@@ -118,24 +118,24 @@ describe YARD::CodeObjects::ModuleObject do
       @mod5.instance_mixins << @proxy
     end
 
-    it "should show only itself for an inheritance tree without included modules" do
-      @mod1.inheritance_tree.should == [@mod1]
+    it "shows only itself for an inheritance tree without included modules" do
+      expect(@mod1.inheritance_tree).to eq [@mod1]
     end
 
-    it "should show proper inheritance three when modules are included" do
-      @mod1.inheritance_tree(true).should == [@mod1, @mod2, @mod3, @mod4]
+    it "shows proper inheritance tree when modules are included" do
+      expect(@mod1.inheritance_tree(true)).to eq [@mod1, @mod2, @mod3, @mod4]
     end
 
-    it "should not list inheritance tree of proxy objects in inheritance tree" do
-      @proxy.should_not_receive(:inheritance_tree)
-      @mod5.instance_mixins.should == [@proxy]
+    it "does not list inheritance tree of proxy objects in inheritance tree" do
+      expect(@proxy).not_to receive(:inheritance_tree)
+      expect(@mod5.instance_mixins).to eq [@proxy]
     end
 
-    it "should list class mixins in inheritance tree" do
+    it "lists class mixins in inheritance tree" do
       mod = ModuleObject.new(:root, :ClassMethods)
       recvmod = ModuleObject.new(:root, :ReceivingModule)
       recvmod.class_mixins << mod
-      recvmod.inheritance_tree(true).should == [recvmod, mod]
+      expect(recvmod.inheritance_tree(true)).to eq [recvmod, mod]
     end
   end
 end

data/spec/code_objects/namespace_object_spec.rb

@@ -3,30 +3,30 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::CodeObjects::NamespaceObject do
   before { Registry.clear }
 
-  describe '#child' do
-    it "should return the object matching the name passed in if argument is a Symbol" do
+  describe "#child" do
+    it "returns the object matching the name passed in if argument is a Symbol" do
       obj = NamespaceObject.new(nil, :YARD)
       other = NamespaceObject.new(obj, :Other)
-      obj.child(:Other).should == other
-      obj.child('Other').should == other
+      expect(obj.child(:Other)).to eq other
+      expect(obj.child('Other')).to eq other
     end
 
-    it "should look for attributes matching the object if the argument is a Hash" do
+    it "looks for attributes matching the object if the argument is a Hash" do
       obj = NamespaceObject.new(nil, :YARD)
       NamespaceObject.new(obj, :NotOther)
       other = NamespaceObject.new(obj, :Other)
       other.somevalue = 2
-      obj.child(:somevalue => 2).should == other
+      expect(obj.child(:somevalue => 2)).to eq other
     end
   end
 
-  describe '#meths' do
-    it "should return #meths even if parent is a Proxy" do
+  describe "#meths" do
+    it "returns #meths even if parent is a Proxy" do
       obj = NamespaceObject.new(P(:String), :YARD)
-      obj.meths.should be_empty
+      expect(obj.meths).to be_empty
     end
 
-    it "should not list included methods that are already defined in the namespace using #meths" do
+    it "does not list included methods that are already defined in the namespace using #meths" do
       a = ModuleObject.new(nil, :Mod1)
       ameth = MethodObject.new(a, :testing)
       b = ModuleObject.new(nil, :Mod2)
@@ -38,33 +38,33 @@ describe YARD::CodeObjects::NamespaceObject do
       c.class_mixins << b
 
       meths = c.meths
-      meths.should include(bmeth)
-      meths.should include(cmeth)
-      meths.should include(cmeth2)
-      meths.should_not include(ameth)
+      expect(meths).to include(bmeth)
+      expect(meths).to include(cmeth)
+      expect(meths).to include(cmeth2)
+      expect(meths).not_to include(ameth)
 
       meths = c.included_meths
-      meths.should include(bmeth)
-      meths.should_not include(ameth)
-      meths.should_not include(cmeth)
-      meths.should_not include(cmeth2)
+      expect(meths).to include(bmeth)
+      expect(meths).not_to include(ameth)
+      expect(meths).not_to include(cmeth)
+      expect(meths).not_to include(cmeth2)
     end
   end
 
-  describe '#included_meths' do
-    it "should list methods mixed into the class scope as class methods" do
+  describe "#included_meths" do
+    it "lists methods mixed into the class scope as class methods" do
       b = ModuleObject.new(nil, :Mod2)
       bmeth = MethodObject.new(b, :foo)
       bmeth2 = MethodObject.new(b, :foo2)
       c = NamespaceObject.new(nil, :YARD)
       c.class_mixins << b
 
-      [bmeth, bmeth2].each {|o| o.scope.should == :instance }
+      [bmeth, bmeth2].each { |o| expect(o.scope).to eq :instance }
       meths = c.included_meths(:scope => :class)
-      meths.each {|o| o.scope.should == :class }
+      meths.each { |o| expect(o.scope).to eq :class }
     end
 
-    it "should not list methods overridden by another included module" do
+    it "does not list methods overridden by another included module" do
       a = ModuleObject.new(nil, :Mod)
       ameth = MethodObject.new(a, :testing)
       b = ModuleObject.new(nil, :Mod2)
@@ -76,38 +76,38 @@ describe YARD::CodeObjects::NamespaceObject do
       c.class_mixins.unshift a
 
       meths = c.included_meths(:scope => :instance)
-      meths.should_not include(ameth)
-      meths.should include(bmeth)
+      expect(meths).not_to include(ameth)
+      expect(meths).to include(bmeth)
 
       meths = c.included_meths(:scope => :class)
-      meths.should include(ameth)
-      meths.should_not include(bmeth)
+      expect(meths).to include(ameth)
+      expect(meths).not_to include(bmeth)
     end
   end
 
-  describe '#class_attributes' do
-    it "should list class attributes" do
+  describe "#class_attributes" do
+    it "lists class attributes" do
       a = NamespaceObject.new(nil, :Mod)
       a.attributes[:instance][:a] = { :read => MethodObject.new(a, :a), :write => nil }
       a.attributes[:instance][:b] = { :read => MethodObject.new(a, :b), :write => nil }
       a.attributes[:class][:a] = { :read => MethodObject.new(a, :a, :class), :write => nil }
-      a.class_attributes.keys.should include(:a)
-      a.class_attributes.keys.should_not include(:b)
+      expect(a.class_attributes.keys).to include(:a)
+      expect(a.class_attributes.keys).not_to include(:b)
     end
   end
 
-  describe '#instance_attributes' do
-    it "should list instance attributes" do
+  describe "#instance_attributes" do
+    it "lists instance attributes" do
       a = NamespaceObject.new(nil, :Mod)
       a.attributes[:instance][:a] = { :read => MethodObject.new(a, :a), :write => nil }
       a.attributes[:instance][:b] = { :read => MethodObject.new(a, :b), :write => nil }
       a.attributes[:class][:a] = { :read => MethodObject.new(a, :a, :class), :write => nil }
-      a.instance_attributes.keys.should include(:a)
-      a.instance_attributes.keys.should include(:b)
+      expect(a.instance_attributes.keys).to include(:a)
+      expect(a.instance_attributes.keys).to include(:b)
     end
   end
 
-  describe '#constants/#included_constants' do
+  describe "#constants/#included_constants" do
     before do
       Registry.clear
 
@@ -132,39 +132,39 @@ describe YARD::CodeObjects::NamespaceObject do
       eof
     end
 
-    it "should list all included constants by default" do
+    it "lists all included constants by default" do
       consts = P(:C).constants
-      consts.should include(P('A::CONST1'))
-      consts.should include(P('C::CONST4'))
+      expect(consts).to include(P('A::CONST1'))
+      expect(consts).to include(P('C::CONST4'))
     end
 
-    it "should allow :included to be set to false to ignore included constants" do
+    it "allows :included to be set to false to ignore included constants" do
       consts = P(:C).constants(:included => false)
-      consts.should_not include(P('A::CONST1'))
-      consts.should include(P('C::CONST4'))
+      expect(consts).not_to include(P('A::CONST1'))
+      expect(consts).to include(P('C::CONST4'))
     end
 
-    it "should not list an included constant if it is defined in the object" do
+    it "does not list an included constant if it is defined in the object" do
       consts = P(:C).constants
-      consts.should include(P('C::CONST3'))
-      consts.should_not include(P('B::CONST3'))
+      expect(consts).to include(P('C::CONST3'))
+      expect(consts).not_to include(P('B::CONST3'))
     end
 
-    it "should not list an included constant if it is shadowed by another included constant" do
+    it "does not list an included constant if it is shadowed by another included constant" do
       consts = P(:C).included_constants
-      consts.should include(P('B::CONST2'))
-      consts.should_not include(P('A::CONST2'))
+      expect(consts).to include(P('B::CONST2'))
+      expect(consts).not_to include(P('A::CONST2'))
     end
   end
 
-  describe '#included_meths' do
-    it "should return all included methods with :all = true" do
+  describe "#included_meths" do
+    it "returns all included methods with :all = true" do
       YARD.parse_string <<-eof
         module B; def foo; end end
         module C; def bar; end end
         class A; include B; include C; def foo; end; def bar; end end
       eof
-      Registry.at('A').included_meths(:all => true).should == [P('C#bar'), P('B#foo')]
+      expect(Registry.at('A').included_meths(:all => true)).to eq [P('C#bar'), P('B#foo')]
     end
   end
 end

data/spec/code_objects/proxy_spec.rb

@@ -3,87 +3,87 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::CodeObjects::Proxy do
   before { Registry.clear }
 
-  it "should return the object if it's in the Registry" do
+  it "returns the object if it's in the Registry" do
     pathobj = ModuleObject.new(:root, :YARD)
     proxyobj = P(:root, :YARD)
-    proxyobj.type.should == :module
-    Proxy.should_not === proxyobj
+    expect(proxyobj.type).to eq :module
+    expect(Proxy === proxyobj).to be false
   end
 
-  it "should handle complex string namespaces" do
+  it "handles complex string namespaces" do
     ModuleObject.new(:root, :A)
     pathobj = ModuleObject.new(P(nil, :A), :B)
-    P(:root, "A::B").should be_instance_of(ModuleObject)
+    expect(P(:root, "A::B")).to be_instance_of(ModuleObject)
   end
 
-  it "should not return true to Proxy === obj if obj is a Proxy class holding a resolved object" do
-    Proxy.should === P(:root, 'a')
-    Proxy.should_not === P(:root)
+  it "does not return true to Proxy === obj if obj is a Proxy class holding a resolved object" do
+    expect(Proxy === P(:root, 'a')).to be true
+    expect(Proxy === P(:root)).to be false
     MethodObject.new(:root, 'a')
-    Proxy.should_not === P(:root, 'a')
+    expect(Proxy === P(:root, 'a')).to be false
     x = Proxy.new(:root, 'a')
-    Proxy.should_not === x
+    expect(Proxy === x).to be false
   end
 
-  it "should return the object if it's an included Module" do
+  it "returns the object if it's an included Module" do
     yardobj = ModuleObject.new(:root, :YARD)
     pathobj = ClassObject.new(:root, :TestClass)
     pathobj.instance_mixins << yardobj
-    P(P(nil, :TestClass), :YARD).should be_instance_of(ModuleObject)
+    expect(P(P(nil, :TestClass), :YARD)).to be_instance_of(ModuleObject)
   end
 
-  it "should respond_to respond_to?" do
+  it "responds to respond_to?" do
     obj = ClassObject.new(:root, :Object)
     yardobj = ModuleObject.new(:root, :YARD)
-    P(:YARD).respond_to?(:children).should == true
-    P(:NOTYARD).respond_to?(:children).should == false
+    expect(P(:YARD).respond_to?(:children)).to be true
+    expect(P(:NOTYARD).respond_to?(:children)).to be false
 
-    P(:YARD).respond_to?(:initialize).should == false
-    P(:YARD).respond_to?(:initialize, true).should == true
-    P(:NOTYARD).respond_to?(:initialize).should == false
-    P(:NOTYARD).respond_to?(:initialize, true).should == true
+    expect(P(:YARD).respond_to?(:initialize)).to be false
+    expect(P(:YARD).respond_to?(:initialize, true)).to be true
+    expect(P(:NOTYARD).respond_to?(:initialize)).to be false
+    expect(P(:NOTYARD).respond_to?(:initialize, true)).to be true
   end
 
-  it "should make itself obvious that it's a proxy" do
+  it "makes itself obvious that it's a proxy" do
     pathobj = P(:root, :YARD)
-    pathobj.class.should == Proxy
-    (Proxy === pathobj).should == true
+    expect(pathobj.class).to eq Proxy
+    expect(Proxy === pathobj).to be true
   end
 
-  it "should pretend it's the object's type if it can resolve" do
+  it "pretends it's the object's type if it can resolve" do
     pathobj = ModuleObject.new(:root, :YARD)
     proxyobj = P(:root, :YARD)
-    proxyobj.should be_instance_of(ModuleObject)
+    expect(proxyobj).to be_instance_of(ModuleObject)
   end
 
-  it "should handle instance method names" do
+  it "handles instance method names" do
     obj = P(nil, '#test')
-    obj.name.should == :test
-    obj.path.should == "#test"
-    obj.namespace.should == Registry.root
+    expect(obj.name).to eq :test
+    expect(obj.path).to eq "#test"
+    expect(obj.namespace).to eq Registry.root
   end
 
-  it "should handle instance method names under a namespace" do
+  it "handles instance method names under a namespace" do
     pathobj = ModuleObject.new(:root, :YARD)
     obj = P(pathobj, "A::B#test")
-    obj.name.should == :test
-    obj.path.should == "A::B#test"
+    expect(obj.name).to eq :test
+    expect(obj.path).to eq "A::B#test"
   end
 
-  it "should allow type to be changed" do
+  it "allows type to be changed" do
     obj = P("InvalidClass")
-    obj.type.should == :proxy
-    Proxy.should === obj
+    expect(obj.type).to eq :proxy
+    expect(Proxy === obj).to be true
     obj.type = :class
-    obj.type.should == :class
+    expect(obj.type).to eq :class
   end
 
-  it "should NOT retain a type change between Proxy objects" do
+  it "does NOT retain a type change between Proxy objects" do
     P("InvalidClass").type = :class
-    P("InvalidClass").type.should == :proxy
+    expect(P("InvalidClass").type).to eq :proxy
   end
 
-  it "should use type to ensure resolved object is of intended type" do
+  it "uses type to ensure resolved object is of intended type" do
     YARD.parse_string <<-eof
       module Foo
         class Bar; end
@@ -92,49 +92,49 @@ describe YARD::CodeObjects::Proxy do
     eof
     proxy = Proxy.new(P('Foo'), 'Bar')
     proxy.type = :method
-    proxy.path.should == 'Foo.Bar'
+    expect(proxy.path).to eq 'Foo.Bar'
   end
 
-  it "should allow type in initializer" do
-    Proxy.new(Registry.root, 'Foo', :method).type.should == :method
-    P(Registry.root, 'Foo', :method).type.should == :method
+  it "allows type in initializer" do
+    expect(Proxy.new(Registry.root, 'Foo', :method).type).to eq :method
+    expect(P(Registry.root, 'Foo', :method).type).to eq :method
   end
 
-  it "should never equal Registry.root" do
-    P("MYPROXY").should_not == Registry.root
-    P("X::A").should_not == Registry.root
+  it "never equals Registry.root" do
+    expect(P("MYPROXY")).not_to eq Registry.root
+    expect(P("X::A")).not_to eq Registry.root
   end
 
-  it "should reset namespace and name when object is resolved" do
+  it "resets namespace and name when object is resolved" do
     obj1 = ModuleObject.new(:root, :YARD)
     obj2 = ModuleObject.new(:root, :NOTYARD)
     resolved = Proxy.new(obj2, :YARD)
-    resolved.should == obj1
-    resolved.namespace.should == Registry.root
-    resolved.name.should == :YARD
+    expect(resolved).to eq obj1
+    expect(resolved.namespace).to eq Registry.root
+    expect(resolved.name).to eq :YARD
   end
 
-  it "should ensure that the correct object was resolved" do
+  it "ensures that the correct object was resolved" do
     foo = ModuleObject.new(:root, :Foo)
     foobar = ModuleObject.new(foo, :Bar)
     foobaz = ClassObject.new(foo, :Baz)
 
     # Remember, we're looking for Qux::Bar, not just 'Bar'
     proxy = Proxy.new(foobar, 'Foo::Qux::Bar')
-    proxy.type.should == :proxy
+    expect(proxy.type).to eq :proxy
 
     qux = ModuleObject.new(foo, :Qux)
     quxbar = ModuleObject.new(qux, :Bar)
 
     # Now it should resolve
-    proxy.type.should == :module
+    expect(proxy.type).to eq :module
   end
 
-  it "should handle constant names in namespaces" do
+  it "handles constant names in namespaces" do
     YARD.parse_string <<-eof
       module A; end; B = A
       module B::C; def foo; end end
     eof
-    Proxy.new(:root, 'B::C').should == Registry.at('A::C')
+    expect(Proxy.new(:root, 'B::C')).to eq Registry.at('A::C')
   end
 end