yard 0.8.7.6 → 0.9.0

data/spec/handlers/c/mixin_handler_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Handlers::C::MixinHandler do
-  it "should add includes to modules or classes" do
+  it "adds includes to modules or classes" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       cBar = rb_define_class("Bar", rb_cObject);
@@ -12,16 +12,16 @@ describe YARD::Handlers::C::MixinHandler do
     foo = Registry.at('Foo')
     bar = Registry.at('Bar')
     baz = Registry.at('Baz')
-    bar.mixins(:instance).should == [foo]
-    baz.mixins(:instance).should == [foo]
+    expect(bar.mixins(:instance)).to eq [foo]
+    expect(baz.mixins(:instance)).to eq [foo]
   end
 
-  it "should add include as proxy if symbol lookup fails" do
+  it "adds include as proxy if symbol lookup fails" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       rb_include_module(mFoo, mXYZ);
     eof
     foo = Registry.at('Foo')
-    foo.mixins(:instance).should == [P('XYZ')]
+    expect(foo.mixins(:instance)).to eq [P('XYZ')]
   end
 end

data/spec/handlers/c/module_handler_spec.rb

@@ -1,42 +1,54 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Handlers::C::ClassHandler do
-  it "should register modules" do
+  it "registers modules" do
     parse_init 'mFoo = rb_define_module("Foo");'
-    Registry.at('Foo').type.should == :module
+    expect(Registry.at('Foo').type).to eq :module
   end
 
-  it "should register classes under namespaces" do
-    parse_init 'mFoo = rb_define_module_under(mBar, "Foo");'
-    Registry.at('Bar::Foo').type.should == :module
+  it "registers classes under namespaces" do
+    parse_init <<-EOF
+      mBar = rb_define_module("Bar");
+      mFoo = rb_define_module_under(mBar, "Foo");
+    EOF
+    expect(Registry.at('Bar::Foo').type).to eq :module
   end
 
-  it "should remember symbol defined with class" do
+  it "remembers symbol defined with class" do
     parse_init(<<-eof)
       cXYZ = rb_define_module("Foo");
       rb_define_method(cXYZ, "bar", bar, 0);
     eof
-    Registry.at('Foo').type.should == :module
-    Registry.at('Foo#bar').should_not be_nil
+    expect(Registry.at('Foo').type).to eq :module
+    expect(Registry.at('Foo#bar')).not_to be nil
   end
 
-  it "should not associate declaration comments as module docstring" do
+  it "does not associate declaration comments as module docstring" do
     parse_init(<<-eof)
       /* Docstring! */
       mFoo = rb_define_module("Foo");
     eof
-    Registry.at('Foo').docstring.should be_blank
+    expect(Registry.at('Foo').docstring).to be_blank
   end
 
-  it "should associate a file with the declaration" do
+  it "associates a file with the declaration" do
     parse_init(<<-eof)
       mFoo = rb_define_module("Foo");
     eof
-    Registry.at('Foo').file.should == '(stdin)'
-    Registry.at('Foo').line.should == 2
+    expect(Registry.at('Foo').file).to eq '(stdin)'
+    expect(Registry.at('Foo').line).to eq 2
   end
 
-  it "should raise undoc error if a class is defined under a namespace that cannot be resolved" do
+  it "resolves namespace variable names across multiple files" do
+    parse_multi_file_init(
+      'mBar = rb_define_module_under(mFoo, "Bar");',
+      'mFoo = rb_define_module("Foo");'
+    )
+
+    expect(Registry.at('Foo::Bar').type).to eq :module
+  end
+
+  it "raises undoc error if a class is defined under a namespace that cannot be resolved" do
     with_parser(:c) do
       undoc_error <<-eof
         void Init_Foo() {
@@ -46,7 +58,7 @@ describe YARD::Handlers::C::ClassHandler do
     end
   end unless ENV['LEGACY']
 
-  it "should raise undoc error if a module is defined under a namespace that cannot be resolved" do
+  it "raises undoc error if a module is defined under a namespace that cannot be resolved" do
     with_parser(:c) do
       undoc_error <<-eof
         void Init_Foo() {

data/spec/handlers/c/override_comment_handler_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Handlers::C::OverrideCommentHandler do
   [:class, :module].each do |type|
-    it "should handle Document-#{type}" do
+    it "handles Document-#{type}" do
       parse(<<-eof)
         void something;
         /* Document-#{type}: A
@@ -10,14 +10,14 @@ describe YARD::Handlers::C::OverrideCommentHandler do
          */
         void
       eof
-      Registry.at('A').type.should == type
-      Registry.at('A').docstring.should == 'Foo bar baz'
-      Registry.at('A').file.should == '(stdin)'
-      Registry.at('A').line.should == 2
+      expect(Registry.at('A').type).to eq type
+      expect(Registry.at('A').docstring).to eq 'Foo bar baz'
+      expect(Registry.at('A').file).to eq '(stdin)'
+      expect(Registry.at('A').line).to eq 2
     end
   end
 
-  it "should handle multiple class/module combinations" do
+  it "handles multiple class/module combinations" do
     parse(<<-eof)
       /* Document-class: A
        * Document-class: B
@@ -25,13 +25,13 @@ describe YARD::Handlers::C::OverrideCommentHandler do
        * Foo bar baz
        */
     eof
-    Registry.at('A').docstring.should == 'Foo bar baz'
-    Registry.at('B').docstring.should == 'Foo bar baz'
-    Registry.at('C').docstring.should == 'Foo bar baz'
-    Registry.at('C').type == :module
+    expect(Registry.at('A').docstring).to eq 'Foo bar baz'
+    expect(Registry.at('B').docstring).to eq 'Foo bar baz'
+    expect(Registry.at('C').docstring).to eq 'Foo bar baz'
+    expect(Registry.at('C').type).to eq :module
   end
 
-  it "should handle Document-class with inheritance" do
+  it "handles Document-class with inheritance" do
     parse(<<-eof)
       /* Document-class: A < B
        * Foo bar baz
@@ -39,8 +39,8 @@ describe YARD::Handlers::C::OverrideCommentHandler do
       void
     eof
     obj = Registry.at('A')
-    obj.type.should == :class
-    obj.docstring.should == 'Foo bar baz'
-    obj.superclass.should == P('B')
+    expect(obj.type).to eq :class
+    expect(obj.docstring).to eq 'Foo bar baz'
+    expect(obj.superclass).to eq P('B')
   end
 end

data/spec/handlers/c/path_handler_spec.rb

@@ -1,28 +1,28 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
 describe YARD::Handlers::C::PathHandler do
-  it 'should track variable names defined under namespaces' do
+  it "tracks variable names defined under namespaces" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
       rb_define_method(cBar, "foo", foo, 1);
     eof
-    Registry.at('Foo::Bar').should_not be_nil
-    Registry.at('Foo::Bar#foo').should_not be_nil
+    expect(Registry.at('Foo::Bar')).not_to be nil
+    expect(Registry.at('Foo::Bar#foo')).not_to be nil
   end
 
-  it 'should track variable names defined under namespaces' do
+  it "tracks variable names defined under namespaces" do
     parse_init <<-eof
       mFoo = rb_define_module("Foo");
       cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
       mBaz = rb_define_module_under(cBar, "Baz");
       rb_define_method(mBaz, "foo", foo, 1);
     eof
-    Registry.at('Foo::Bar::Baz').should_not be_nil
-    Registry.at('Foo::Bar::Baz#foo').should_not be_nil
+    expect(Registry.at('Foo::Bar::Baz')).not_to be nil
+    expect(Registry.at('Foo::Bar::Baz#foo')).not_to be nil
   end
 
-  it "should handle rb_path2class() calls" do
+  it "handles rb_path2class() calls" do
     parse_init <<-eof
       somePath = rb_path2class("Foo::Bar::Baz")
       mFoo = rb_define_module("Foo");
@@ -30,6 +30,6 @@ describe YARD::Handlers::C::PathHandler do
       mBaz = rb_define_module_under(cBar, "Baz");
       rb_define_method(somePath, "foo", foo, 1);
     eof
-    Registry.at('Foo::Bar::Baz#foo').should_not be_nil
+    expect(Registry.at('Foo::Bar::Baz#foo')).not_to be nil
   end
 end

data/spec/handlers/c/spec_helper.rb

@@ -11,3 +11,13 @@ def parse_init(src)
   YARD::Registry.clear
   YARD.parse_string("void Init_Foo() {\n#{src}\n}", :c)
 end
+
+def parse_multi_file_init(*srcs)
+  YARD::Registry.clear
+  srcs = srcs.map {|src| StringIO.new("void Init_Foo() {\n#{src}\n}") }
+  orig_type = YARD::Parser::SourceParser.parser_type
+  YARD::Parser::SourceParser.parser_type = :c
+  YARD::Parser::OrderedParser.new(OpenStruct.new, srcs).parse
+ensure
+  YARD::Parser::SourceParser.parser_type = orig_type
+end

data/spec/handlers/c/struct_handler_spec.rb

@@ -3,13 +3,13 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::Handlers::C::StructHandler do
   after { Registry.clear }
 
-  it "should handle Struct class definitions" do
+  it "handles Struct class definitions" do
     parse_init <<-eof
       rb_cRange = rb_struct_define_without_accessor(
           "Range", rb_cFoo, range_alloc,
           "begin", "end", "excl", NULL);
     eof
-    Registry.at('Range').type.should == :class
-    Registry.at('Range').superclass.should == P(:Foo)
+    expect(Registry.at('Range').type).to eq :class
+    expect(Registry.at('Range').superclass).to eq P(:Foo)
   end
 end

data/spec/handlers/class_condition_handler_spec.rb

@@ -4,58 +4,58 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassCondition
   before(:all) { parse_file :class_condition_handler_001, __FILE__ }
 
   def verify_method(*names)
-    names.each {|name| Registry.at("A##{name}").should_not be_nil }
-    names.each {|name| Registry.at("A##{name}not").should be_nil }
+    names.each {|name| expect(Registry.at("A##{name}")).not_to be nil }
+    names.each {|name| expect(Registry.at("A##{name}not")).to be nil }
   end
 
   def no_undoc_error(code)
-    lambda { StubbedSourceParser.parse_string(code) }.should_not raise_error
+    expect { StubbedSourceParser.parse_string(code) }.not_to raise_error
   end
 
-  it "should parse all unless blocks for complex conditions" do
+  it "parses all unless blocks for complex conditions" do
     verify_method :g
   end
 
-  it "should not parse conditionals inside methods" do
+  it "does not parse conditionals inside methods" do
     verify_method :h
   end
 
-  it "should only parse then block if condition is literal value `true`" do
+  it "only parses then block if condition is literal value `true`" do
     verify_method :p
   end
 
-  it "should only parse then block if condition is literal integer != 0" do
+  it "only parses then block if condition is literal integer != 0" do
     verify_method :o
   end
 
-  it "should invert block to parse for literal condition if it's an unless block" do
+  it "inverts block to parse for literal condition if it's an unless block" do
     verify_method :e
   end
 
-  it "should handle conditions such as 'defined? VALUE'" do
+  it "handles conditions such as 'defined? VALUE'" do
     verify_method :j, :k
   end
 
-  it "should parse all if/elsif blocks for complex conditions" do
+  it "parses all if/elsif blocks for complex conditions" do
     verify_method :a, :b, :c, :d
   end
 
-  it "should only parse else block if condition is literal value `false`" do
+  it "parses else block if condition is literal value `false`" do
     verify_method :q
   end
 
-  it "should only parse else block if condition is literal integer == 0" do
+  it "only parses else block if condition is literal integer == 0" do
     verify_method :n
   end
 
-  it "should maintain visibility and scope state inside condition" do
-    Registry.at('A#m').visibility.should == :private
-    Registry.at('A#mnot').visibility.should == :private
+  it "maintains visibility and scope state inside condition" do
+    expect(Registry.at('A#m').visibility).to eq :private
+    expect(Registry.at('A#mnot').visibility).to eq :private
   end
 
-  it "should not fail on complex conditions" do
-    log.should_not_receive(:warn)
-    log.should_not_receive(:error)
+  it "does not fail on complex conditions" do
+    expect(log).not_to receive(:warn)
+    expect(log).not_to receive(:error)
     no_undoc_error "if defined?(A) && defined?(B); puts 'hi' end"
     no_undoc_error(<<-eof)
       (<<-TEST) unless defined?(ABCD_MODEL_TEST)

data/spec/handlers/class_handler_spec.rb

@@ -3,176 +3,176 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
   before(:all) { parse_file :class_handler_001, __FILE__ }
 
-  it "should parse a class block with docstring" do
-    P("A").docstring.should == "Docstring"
+  it "parses a class block with docstring" do
+    expect(P("A").docstring).to eq "Docstring"
   end
 
-  it "should handle complex class names" do
-    P("A::B::C").should_not == nil
+  it "handles complex class names" do
+    expect(P("A::B::C")).not_to eq nil
   end
 
-  it "should handle the subclassing syntax" do
-    P("A::B::C").superclass.should == P(:String)
-    P("A::X").superclass.should == Registry.at("A::B::C")
+  it "handles the subclassing syntax" do
+    expect(P("A::B::C").superclass).to eq P(:String)
+    expect(P("A::X").superclass).to eq Registry.at("A::B::C")
   end
 
-  it "should interpret class << self as a class level block" do
-    P("A.classmethod1").should_not == nil
+  it "interprets class << self as a class level block" do
+    expect(P("A.classmethod1")).not_to eq nil
   end
 
-  it "should interpret class << ClassName as a class level block in ClassName's namespace" do
-    P("A::B::C.Hello").should be_instance_of(CodeObjects::MethodObject)
+  it "interprets class << ClassName as a class level block in ClassName's namespace" do
+    expect(P("A::B::C.Hello")).to be_instance_of(CodeObjects::MethodObject)
   end
 
-  it "should make visibility public when parsing a block" do
-    P("A::B::C#method1").visibility.should == :public
+  it "makes visibility public when parsing a block" do
+    expect(P("A::B::C#method1").visibility).to eq :public
   end
 
-  it "should set superclass type to :class if it is a Proxy" do
-    P("A::B::C").superclass.type.should == :class
+  it "sets superclass type to :class if it is a Proxy" do
+    expect(P("A::B::C").superclass.type).to eq :class
   end
 
-  it "should look for a superclass before creating the class if it shares the same name" do
-    P('B::A').superclass.should == P('A')
+  it "looks for a superclass before creating the class if it shares the same name" do
+    expect(P('B::A').superclass).to eq P('A')
   end
 
-  it "should handle class definitions in the form ::ClassName" do
-    Registry.at("MyRootClass").should_not be_nil
+  it "handles class definitions in the form ::ClassName" do
+    expect(Registry.at("MyRootClass")).not_to be nil
   end
 
-  it "should handle superclass as a constant-style method (camping style < R /path/)" do
-    P('Test1').superclass.should == P(:R)
-    P('Test2').superclass.should == P(:R)
-    P('Test6').superclass.should == P(:NotDelegateClass)
+  it "handles superclass as a constant-style method (camping style < R /path/)" do
+    expect(P('Test1').superclass).to eq P(:R)
+    expect(P('Test2').superclass).to eq P(:R)
+    expect(P('Test6').superclass).to eq P(:NotDelegateClass)
   end
 
-  it "should handle superclass with OStruct.new or Struct.new syntax (superclass should be OStruct/Struct)" do
-    P('Test3').superclass.should == P(:Struct)
-    P('Test4').superclass.should == P(:OStruct)
+  it "handles superclass with OStruct.new or Struct.new syntax (superclass should be OStruct/Struct)" do
+    expect(P('Test3').superclass).to eq P(:Struct)
+    expect(P('Test4').superclass).to eq P(:OStruct)
   end
 
-  it "should handle DelegateClass(CLASSNAME) superclass syntax" do
-    P('Test5').superclass.should == P(:Array)
+  it "handles DelegateClass(CLASSNAME) superclass syntax" do
+    expect(P('Test5').superclass).to eq P(:Array)
   end
 
-  it "should handle a superclass of the same name in the form ::ClassName" do
-    P('Q::Logger').superclass.should == P(:Logger)
-    P('Q::Foo').superclass.should_not == P('Q::Logger')
+  it "handles a superclass of the same name in the form ::ClassName" do
+    expect(P('Q::Logger').superclass).to eq P(:Logger)
+    expect(P('Q::Foo').superclass).not_to eq P('Q::Logger')
   end
 
   ["CallMethod('test')", "VSD^#}}", 'not.aclass', 'self'].each do |klass|
-    it "should raise an UndocumentableError for invalid class '#{klass}'" do
+    it "raises an UndocumentableError for invalid class '#{klass}'" do
       with_parser(:ruby18) { undoc_error "class #{klass}; end" }
     end
   end
 
   ['@@INVALID', 'hi', '$MYCLASS', 'AnotherClass.new'].each do |klass|
-    it "should raise an UndocumentableError for invalid superclass '#{klass}' but it should create the class." do
-      YARD::CodeObjects::ClassObject.should_receive(:new).with(Registry.root, 'A')
+    it "raises an UndocumentableError for invalid superclass '#{klass}' but it should create the class." do
+      expect(YARD::CodeObjects::ClassObject).to receive(:new).with(Registry.root, 'A')
       with_parser(:ruby18) { undoc_error "class A < #{klass}; end" }
-      Registry.at('A').superclass.should == P(:Object)
+      expect(Registry.at('A').superclass).to eq P(:Object)
     end
   end
 
   ['not.aclass', 'self', 'AnotherClass.new'].each do |klass|
-    it "should raise an UndocumentableError if the constant class reference 'class << SomeConstant' does not point to a valid class name" do
+    it "raises an UndocumentableError if the constant class reference 'class << SomeConstant' does not point to a valid class name" do
       with_parser(:ruby18) do
         undoc_error <<-eof
           CONST = #{klass}
           class << CONST; end
         eof
       end
-      Registry.at(klass).should be_nil
+      expect(Registry.at(klass)).to be nil
     end
   end
 
-  it "should document 'class << SomeConstant' by using SomeConstant's value as a reference to the real class name" do
-    Registry.at('String.classmethod').should_not be_nil
+  it "documents 'class << SomeConstant' by using SomeConstant's value as a reference to the real class name" do
+    expect(Registry.at('String.classmethod')).not_to be nil
   end
 
-  it "should allow class << SomeRubyClass to create the class if it does not exist" do
-    Registry.at('Symbol.toString').should_not be_nil
+  it "allows class << SomeRubyClass to create the class if it does not exist" do
+    expect(Registry.at('Symbol.toString')).not_to be nil
   end
 
-  it "should document 'class Exception' without running into superclass issues" do
+  it "documents 'class Exception' without running into superclass issues" do
     Parser::SourceParser.parse_string <<-eof
       class Exception
       end
     eof
-    Registry.at(:Exception).should_not be_nil
+    expect(Registry.at(:Exception)).not_to be nil
   end
 
-  it "should document 'class RT < XX::RT' with proper superclass even if XX::RT is a proxy" do
-    Registry.at(:RT).should_not be_nil
-    Registry.at(:RT).superclass.should == P('XX::RT')
+  it "documents 'class RT < XX::RT' with proper superclass even if XX::RT is a proxy" do
+    expect(Registry.at(:RT)).not_to be nil
+    expect(Registry.at(:RT).superclass).to eq P('XX::RT')
   end
 
-  it "should not overwrite docstring with an empty one" do
-    Registry.at(:Zebra).docstring.should == "Docstring 2"
+  it "does not overwrite docstring with an empty one" do
+    expect(Registry.at(:Zebra).docstring).to eq "Docstring 2"
   end
 
-  it "should turn 'class Const < Struct.new(:sym)' into class Const with attr :sym" do
+  it "turns 'class Const < Struct.new(:sym)' into class Const with attr :sym" do
     obj = Registry.at("Point")
-    obj.should be_kind_of(CodeObjects::ClassObject)
+    expect(obj).to be_kind_of(CodeObjects::ClassObject)
     attrs = obj.attributes[:instance]
     [:x, :y, :z].each do |key|
-      attrs.should have_key(key)
-      attrs[key][:read].should_not be_nil
-      attrs[key][:write].should_not be_nil
+      expect(attrs).to have_key(key)
+      expect(attrs[key][:read]).not_to be nil
+      expect(attrs[key][:write]).not_to be nil
     end
   end
 
-  it "should turn 'class Const < Struct.new('Name', :sym)' into class Const with attr :sym" do
+  it "turns 'class Const < Struct.new('Name', :sym)' into class Const with attr :sym" do
     obj = Registry.at("AnotherPoint")
-    obj.should be_kind_of(CodeObjects::ClassObject)
+    expect(obj).to be_kind_of(CodeObjects::ClassObject)
     attrs = obj.attributes[:instance]
     [:a, :b, :c].each do |key|
-      attrs.should have_key(key)
-      attrs[key][:read].should_not be_nil
-      attrs[key][:write].should_not be_nil
+      expect(attrs).to have_key(key)
+      expect(attrs[key][:read]).not_to be nil
+      expect(attrs[key][:write]).not_to be nil
     end
 
-    Registry.at("XPoint").should be_nil
+    expect(Registry.at("XPoint")).to be nil
   end
 
-  it "should create a Struct::Name class when class Const < Struct.new('Name', :sym) is found" do
+  it "creates a Struct::Name class when class Const < Struct.new('Name', :sym) is found" do
     obj = Registry.at("Struct::XPoint")
-    obj.should_not be_nil
+    expect(obj).not_to be nil
   end
 
-  it "should attach attribtues to the generated Struct::Name class when Struct.new('Name') is used" do
+  it "attaches attribtues to the generated Struct::Name class when Struct.new('Name') is used" do
     obj = Registry.at("Struct::XPoint")
     attrs = obj.attributes[:instance]
     [:a, :b, :c].each do |key|
-      attrs.should have_key(key)
-      attrs[key][:read].should_not be_nil
-      attrs[key][:write].should_not be_nil
+      expect(attrs).to have_key(key)
+      expect(attrs[key][:read]).not_to be nil
+      expect(attrs[key][:write]).not_to be nil
     end
   end
 
-  it "should use @attr to set attribute descriptions on Struct subclasses" do
+  it "uses @attr to set attribute descriptions on Struct subclasses" do
     obj = Registry.at("DoccedStruct#input")
-    obj.docstring.should == "the input stream"
+    expect(obj.docstring).to eq "the input stream"
   end
 
-  it "should use @attr to set attribute types on Struct subclasses" do
+  it "uses @attr to set attribute types on Struct subclasses" do
     obj = Registry.at("DoccedStruct#someproc")
-    obj.should_not be_nil
-    obj.tag(:return).should_not be_nil
-    obj.tag(:return).types.should == ["Proc", "#call"]
+    expect(obj).not_to be nil
+    expect(obj.tag(:return)).not_to be nil
+    expect(obj.tag(:return).types).to eq ["Proc", "#call"]
   end
 
-  it "should default types unspecified by @attr to Object on Struct subclasses" do
+  it "defaults types unspecified by @attr to Object on Struct subclasses" do
     obj = Registry.at("DoccedStruct#mode")
-    obj.should_not be_nil
-    obj.tag(:return).should_not be_nil
-    obj.tag(:return).types.should == ["Object"]
+    expect(obj).not_to be nil
+    expect(obj.tag(:return)).not_to be nil
+    expect(obj.tag(:return).types).to eq ["Object"]
   end
 
-  it "should create parameters for writers of Struct subclass's attributes" do
+  it "creates parameters for writers of Struct subclass's attributes" do
     obj = Registry.at("DoccedStruct#input=")
-    obj.tags(:param).size.should == 1
-    obj.tag(:param).types.should == ["IO"]
+    expect(obj.tags(:param).size).to eq 1
+    expect(obj.tag(:param).types).to eq ["IO"]
   end
 
   ["SemiDoccedStruct", "NotAStruct"].each do |struct|
@@ -180,67 +180,67 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler"
       it "defines both readers and writers when @attr is used on Structs" do
         obj = Registry.at(struct)
         attrs = obj.attributes[:instance]
-        attrs[:first][:read].should_not be_nil
-        attrs[:first][:write].should_not be_nil
+        expect(attrs[:first][:read]).not_to be nil
+        expect(attrs[:first][:write]).not_to be nil
       end
 
       it "defines only a reader when only @attr_reader is used on Structs" do
         obj = Registry.at(struct)
         attrs = obj.attributes[:instance]
-        attrs[:second][:read].should_not be_nil
-        attrs[:second][:write].should be_nil
+        expect(attrs[:second][:read]).not_to be nil
+        expect(attrs[:second][:write]).to be nil
       end
 
       it "defines only a writer when only @attr_writer is used on Structs" do
         obj = Registry.at(struct)
         attrs = obj.attributes[:instance]
-        attrs[:third][:read].should be_nil
-        attrs[:third][:write].should_not be_nil
+        expect(attrs[:third][:read]).to be nil
+        expect(attrs[:third][:write]).not_to be nil
       end
 
       it "defines a reader with correct return types when @attr_reader is used on Structs" do
         obj = Registry.at("#{struct}#second")
-        obj.tag(:return).types.should == ["Fixnum"]
+        expect(obj.tag(:return).types).to eq ["Fixnum"]
       end
 
       it "defines a writer with correct parameter types when @attr_writer is used on Structs" do
         obj = Registry.at("#{struct}#third=")
-        obj.tag(:param).types.should == ["Array"]
+        expect(obj.tag(:param).types).to eq ["Array"]
       end
 
       it "defines a reader and a writer when both @attr_reader and @attr_writer are used" do
         obj = Registry.at(struct)
         attrs = obj.attributes[:instance]
-        attrs[:fourth][:read].should_not be_nil
-        attrs[:fourth][:write].should_not be_nil
+        expect(attrs[:fourth][:read]).not_to be nil
+        expect(attrs[:fourth][:write]).not_to be nil
       end
 
       it "uses @attr_reader for the getter when both @attr_reader and @attr_writer are given" do
         obj = Registry.at("#{struct}#fourth")
-        obj.tag(:return).types.should == ["#read"]
+        expect(obj.tag(:return).types).to eq ["#read"]
       end
 
       it "uses @attr_writer for the setter when both @attr_reader and @attr_writer are given" do
         obj = Registry.at("#{struct}#fourth=")
-        obj.tag(:param).types.should == ["IO"]
+        expect(obj.tag(:param).types).to eq ["IO"]
       end
 
       it "extracts text from @attr_reader" do
-        Registry.at("#{struct}#fourth").docstring.should == "returns a proc that reads"
+        expect(Registry.at("#{struct}#fourth").docstring).to eq "returns a proc that reads"
       end
 
       it "extracts text from @attr_writer" do
-        Registry.at("#{struct}#fourth=").docstring.should == "sets the proc that writes stuff"
+        expect(Registry.at("#{struct}#fourth=").docstring).to eq "sets the proc that writes stuff"
       end
     end
   end
 
-  it "should inherit from a regular struct" do
-    Registry.at('RegularStruct').superclass.should == P(:Struct)
-    Registry.at('RegularStruct2').superclass.should == P(:Struct)
+  it "inherits from a regular struct" do
+    expect(Registry.at('RegularStruct').superclass).to eq P(:Struct)
+    expect(Registry.at('RegularStruct2').superclass).to eq P(:Struct)
   end
 
-  it "should handle inheritance from 'self'" do
-    Registry.at('Outer1::Inner1').superclass.should == Registry.at('Outer1')
+  it "handles inheritance from 'self'" do
+    expect(Registry.at('Outer1::Inner1').superclass).to eq Registry.at('Outer1')
   end
 end