yard 0.8.7.6 → 0.9.0

data/spec/code_objects/class_object_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::CodeObjects::ClassObject do
-  describe '#inheritance_tree' do
+  describe "#inheritance_tree" do
     before(:all) do
       Registry.clear
       @mixin = ModuleObject.new(:root, :SomeMixin)
@@ -19,28 +19,28 @@ describe YARD::CodeObjects::ClassObject do
       @yard.instance_mixins << @mixin
     end
 
-    it "should show the proper inheritance tree" do
-      @yard.inheritance_tree.should == [@yard, @superyard, P(:String)]
+    it "shows the proper inheritance tree" do
+      expect(@yard.inheritance_tree).to eq [@yard, @superyard, P(:String)]
     end
 
-    it "should show proper inheritance tree when mixins are included" do
-      @yard.inheritance_tree(true).should == [@yard, @mixin, @superyard, @mixin4, @mixin2, @mixin3, P(:String)]
+    it "shows proper inheritance tree when mixins are included" do
+      expect(@yard.inheritance_tree(true)).to eq [@yard, @mixin, @superyard, @mixin4, @mixin2, @mixin3, P(:String)]
     end
 
-    it "should not modify the object's mixin list when mixins are included" do
+    it "does not modify the object's mixin list when mixins are included" do
       @class1 = ClassObject.new(:root, :A)
       @class2 = ClassObject.new(:root, :B)
       @class2.superclass = @class1
 
       @class2.inheritance_tree(true)
-      @class2.mixins.should == []
+      expect(@class2.mixins).to eq []
     end
 
-    it "should list class mixins in inheritance tree" do
+    it "lists class mixins in inheritance tree" do
       mod = ModuleObject.new(:root, :ClassMethods)
       klass = ClassObject.new(:root, :ReceivingClass)
       klass.class_mixins << mod
-      klass.inheritance_tree(true).should == [klass, mod]
+      expect(klass.inheritance_tree(true)).to eq [klass, mod]
     end
   end
 
@@ -78,45 +78,45 @@ describe YARD::CodeObjects::ClassObject do
       eof
     end
 
-    it "should show inherited methods by default" do
+    it "shows inherited methods by default" do
       meths = P(:YARD).meths
-      meths.should include(P("YARD#mymethod"))
-      meths.should include(P("SuperYard#foo"))
-      meths.should include(P("SuperYard#foo2"))
-      meths.should include(P("SuperYard.bar"))
+      expect(meths).to include(P("YARD#mymethod"))
+      expect(meths).to include(P("SuperYard#foo"))
+      expect(meths).to include(P("SuperYard#foo2"))
+      expect(meths).to include(P("SuperYard.bar"))
     end
 
-    it "should allow :inherited to be set to false" do
+    it "allows :inherited to be set to false" do
       meths = P(:YARD).meths(:inherited => false)
-      meths.should include(P("YARD#mymethod"))
-      meths.should_not include(P("SuperYard#foo"))
-      meths.should_not include(P("SuperYard#foo2"))
-      meths.should_not include(P("SuperYard.bar"))
+      expect(meths).to include(P("YARD#mymethod"))
+      expect(meths).not_to include(P("SuperYard#foo"))
+      expect(meths).not_to include(P("SuperYard#foo2"))
+      expect(meths).not_to include(P("SuperYard.bar"))
     end
 
-    it "should not show overridden methods" do
+    it "does not show overridden methods" do
       meths = P(:YARD).meths
-      meths.should include(P("YARD#bar"))
-      meths.should_not include(P("SuperYard#bar"))
+      expect(meths).to include(P("YARD#bar"))
+      expect(meths).not_to include(P("SuperYard#bar"))
 
       meths = P(:YARD).inherited_meths
-      meths.should_not include(P("YARD#bar"))
-      meths.should_not include(P("YARD#mymethod"))
-      meths.should include(P("SuperYard#foo"))
-      meths.should include(P("SuperYard#foo2"))
-      meths.should include(P("SuperYard.bar"))
+      expect(meths).not_to include(P("YARD#bar"))
+      expect(meths).not_to include(P("YARD#mymethod"))
+      expect(meths).to include(P("SuperYard#foo"))
+      expect(meths).to include(P("SuperYard#foo2"))
+      expect(meths).to include(P("SuperYard.bar"))
     end
 
-    it "should not show inherited methods overridden by other subclasses" do
+    it "does not show inherited methods overridden by other subclasses" do
       meths = P(:YARD).inherited_meths
-      meths.should include(P('MiddleYard#middle'))
-      meths.should_not include(P('SuperYard#middle'))
+      expect(meths).to include(P('MiddleYard#middle'))
+      expect(meths).not_to include(P('SuperYard#middle'))
     end
 
-    it "should show mixed in methods before superclass method" do
+    it "shows mixed in methods before superclass method" do
       meths = P(:FinalYard).meths
-      meths.should include(P('IncludedYard#foo'))
-      meths.should_not include(P('SuperYard#foo'))
+      expect(meths).to include(P('IncludedYard#foo'))
+      expect(meths).not_to include(P('SuperYard#foo'))
     end
   end
 
@@ -142,55 +142,55 @@ describe YARD::CodeObjects::ClassObject do
       eof
     end
 
-    it "should list inherited constants by default" do
+    it "lists inherited constants by default" do
       consts = P(:SubYard).constants
-      consts.should include(P("YARD::CONST1"))
-      consts.should include(P("SubYard::CONST3"))
+      expect(consts).to include(P("YARD::CONST1"))
+      expect(consts).to include(P("SubYard::CONST3"))
 
       consts = P(:SubYard).inherited_constants
-      consts.should include(P("YARD::CONST1"))
-      consts.should_not include(P("YARD::CONST2"))
-      consts.should_not include(P("SubYard::CONST2"))
-      consts.should_not include(P("SubYard::CONST3"))
+      expect(consts).to include(P("YARD::CONST1"))
+      expect(consts).not_to include(P("YARD::CONST2"))
+      expect(consts).not_to include(P("SubYard::CONST2"))
+      expect(consts).not_to include(P("SubYard::CONST3"))
     end
 
-    it "should not list inherited constants if turned off" do
+    it "does not list inherited constants if turned off" do
       consts = P(:SubYard).constants(:inherited => false)
-      consts.should_not include(P("YARD::CONST1"))
-      consts.should include(P("SubYard::CONST3"))
+      expect(consts).not_to include(P("YARD::CONST1"))
+      expect(consts).to include(P("SubYard::CONST3"))
     end
 
-    it "should not include an inherited constant if it is overridden by the object" do
+    it "does not include an inherited constant if it is overridden by the object" do
       consts = P(:SubYard).constants
-      consts.should include(P("SubYard::CONST2"))
-      consts.should_not include(P("YARD::CONST2"))
+      expect(consts).to include(P("SubYard::CONST2"))
+      expect(consts).not_to include(P("YARD::CONST2"))
     end
 
-    it "should not include an inherited constant if it is overridden by another subclass" do
+    it "does not include an inherited constant if it is overridden by another subclass" do
       consts = P(:SubYard).inherited_constants
-      consts.should include(P("SUPERYARD::CONST4"))
-      consts.should_not include(P("YARD::CONST4"))
+      expect(consts).to include(P("SUPERYARD::CONST4"))
+      expect(consts).not_to include(P("YARD::CONST4"))
     end
 
-    it "should not set a superclass on BasicObject class" do
+    it "does not set a superclass on BasicObject class" do
       o = ClassObject.new(:root, :Object)
-      o.superclass.should == P(:BasicObject)
+      expect(o.superclass).to eq P(:BasicObject)
     end
 
-    it "should set superclass of Object to BasicObject" do
+    it "sets superclass of Object to BasicObject" do
       o = ClassObject.new(:root, :BasicObject)
-      o.superclass.should be_nil
+      expect(o.superclass).to be nil
     end
 
-    it "should raise ArgumentError if superclass == self" do
-      lambda do
+    it "raises ArgumentError if superclass == self" do
+      expect do
         o = ClassObject.new(:root, :Object) do |o|
           o.superclass = :Object
         end
-      end.should raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
-    it "should tell the world if it is an exception class" do
+    it "tells the world if it is an exception class" do
       o = ClassObject.new(:root, :MyClass)
       o2 = ClassObject.new(:root, :OtherClass)
       o2.superclass = :SystemCallError
@@ -199,27 +199,27 @@ describe YARD::CodeObjects::ClassObject do
       o4 = ClassObject.new(:root, :Object)
 
       o.superclass = :Object
-      o.is_exception?.should == false
+      expect(o.is_exception?).to be false
 
       o.superclass = :Exception
-      o.is_exception?.should == true
+      expect(o.is_exception?).to be true
 
       o.superclass = :NoMethodError
-      o.is_exception?.should == true
+      expect(o.is_exception?).to be true
 
       o.superclass = o2
-      o.is_exception?.should == true
+      expect(o.is_exception?).to be true
 
       o.superclass = o3
-      o.is_exception?.should == true
+      expect(o.is_exception?).to be true
     end
 
-    it "should not raise ArgumentError if superclass is proxy in different namespace" do
-      lambda do
+    it "does not raise ArgumentError if superclass is proxy in different namespace" do
+      expect do
         o = ClassObject.new(:root, :X) do |o|
           o.superclass = P('OTHER::X')
         end
-      end.should_not raise_error(ArgumentError)
+      end.not_to raise_error
     end
   end
 end

data/spec/code_objects/code_object_list_spec.rb

@@ -3,31 +3,33 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::CodeObjects::CodeObjectList do
   before { Registry.clear }
 
-  it "pushing a value should only allow CodeObjects::Base, String or Symbol" do
-    list = CodeObjectList.new(nil)
-    lambda { list.push(:hash => 1) }.should raise_error(ArgumentError)
-    list << "Test"
-    list << :Test2
-    list << ModuleObject.new(nil, :YARD)
-    list.size.should == 3
+  describe "#push" do
+    it "only allows CodeObjects::Base, String or Symbol" do
+      list = CodeObjectList.new(nil)
+      expect { list.push(:hash => 1) }.to raise_error(ArgumentError)
+      list << "Test"
+      list << :Test2
+      list << ModuleObject.new(nil, :YARD)
+      expect(list.size).to eq 3
+    end
   end
 
   it "added value should be a proxy if parameter was String or Symbol" do
     list = CodeObjectList.new(nil)
     list << "Test"
-    list.first.class.should == Proxy
+    expect(list.first.class).to eq Proxy
   end
 
-  it "should contain a unique list of objects" do
+  it "contains a unique list of objects" do
     obj = ModuleObject.new(nil, :YARD)
     list = CodeObjectList.new(nil)
 
     list << P(:YARD)
     list << obj
-    list.size.should == 1
+    expect(list.size).to eq 1
 
     list << :Test
     list << "Test"
-    list.size.should == 2
+    expect(list.size).to eq 2
   end
 end

data/spec/code_objects/constants_spec.rb

@@ -1,82 +1,92 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe YARD::CodeObjects, "CONSTANTMATCH" do
-  it "should match a constant" do
-    "Constant"[CodeObjects::CONSTANTMATCH].should == "Constant"
-    "identifier"[CodeObjects::CONSTANTMATCH].should be_nil
-    "File.new"[CodeObjects::CONSTANTMATCH].should == "File"
+describe YARD::CodeObjects do
+  describe :CONSTANTMATCH do
+    it "matches a constant" do
+      expect("Constant"[CodeObjects::CONSTANTMATCH]).to eq "Constant"
+      expect("identifier"[CodeObjects::CONSTANTMATCH]).to be nil
+      expect("File.new"[CodeObjects::CONSTANTMATCH]).to eq "File"
+    end
   end
-end
 
-describe YARD::CodeObjects, "NAMESPACEMATCH" do
-  it "should match a namespace (multiple constants with ::)" do
-    "Constant"[CodeObjects::NAMESPACEMATCH].should == "Constant"
-    "A::B::C.new"[CodeObjects::NAMESPACEMATCH].should == "A::B::C"
+  describe :CONSTANTSTART do
+    it "matches a constant" do
+      expect("Constant"[CodeObjects::CONSTANTSTART]).to eq "C"
+      expect("identifier"[CodeObjects::CONSTANTSTART]).to be nil
+      expect("File.new"[CodeObjects::CONSTANTSTART]).to eq "F"
+    end
   end
-end
 
-describe YARD::CodeObjects, "METHODNAMEMATCH" do
-  it "should match a method name" do
-    "method"[CodeObjects::METHODNAMEMATCH].should == "method"
-    "[]()"[CodeObjects::METHODNAMEMATCH].should == "[]"
-    "-@"[CodeObjects::METHODNAMEMATCH].should == "-@"
-    "method?"[CodeObjects::METHODNAMEMATCH].should == "method?"
-    "method!!"[CodeObjects::METHODNAMEMATCH].should == "method!"
+  describe :NAMESPACEMATCH do
+    it "matches a namespace (multiple constants with ::)" do
+      expect("Constant"[CodeObjects::NAMESPACEMATCH]).to eq "Constant"
+      expect("A::B::C.new"[CodeObjects::NAMESPACEMATCH]).to eq "A::B::C"
+    end
   end
-end
 
-describe YARD::CodeObjects, "METHODMATCH" do
-  it "should match a full class method path" do
-    "method"[CodeObjects::METHODMATCH].should == "method"
-    "A::B::C.method?"[CodeObjects::METHODMATCH].should == "A::B::C.method?"
-    "A::B::C :: method"[CodeObjects::METHODMATCH].should == "A::B::C :: method"
-    "SomeClass . method"[CodeObjects::METHODMATCH].should == "SomeClass . method"
+  describe :METHODNAMEMATCH do
+    it "matches a method name" do
+      expect("method"[CodeObjects::METHODNAMEMATCH]).to eq "method"
+      expect("[]()"[CodeObjects::METHODNAMEMATCH]).to eq "[]"
+      expect("-@"[CodeObjects::METHODNAMEMATCH]).to eq "-@"
+      expect("method?"[CodeObjects::METHODNAMEMATCH]).to eq "method?"
+      expect("method!!"[CodeObjects::METHODNAMEMATCH]).to eq "method!"
+    end
   end
 
-  it "should match self.method" do
-    "self :: method!"[CodeObjects::METHODMATCH].should == "self :: method!"
-    "self.is_a?"[CodeObjects::METHODMATCH].should == "self.is_a?"
-  end
-end
+  describe :METHODMATCH do
+    it "matches a full class method path" do
+      expect("method"[CodeObjects::METHODMATCH]).to eq "method"
+      expect("A::B::C.method?"[CodeObjects::METHODMATCH]).to eq "A::B::C.method?"
+      expect("A::B::C :: method"[CodeObjects::METHODMATCH]).to eq "A::B::C :: method"
+      expect("SomeClass . method"[CodeObjects::METHODMATCH]).to eq "SomeClass . method"
+    end
 
-describe YARD::CodeObjects, "BUILTIN_EXCEPTIONS" do
-  it "should include all base exceptions" do
-    YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
-      eval(name).should <= Exception
+    it "matches self.method" do
+      expect("self :: method!"[CodeObjects::METHODMATCH]).to eq "self :: method!"
+      expect("self.is_a?"[CodeObjects::METHODMATCH]).to eq "self.is_a?"
     end
   end
-end
 
-describe YARD::CodeObjects, "BUILTIN_CLASSES" do
-  it "should include all base classes" do
-    YARD::CodeObjects::BUILTIN_CLASSES.each do |name|
-      next if name == "MatchingData" && !defined?(::MatchingData)
-      next if name == "Continuation"
-      eval(name).should be_instance_of(Class)
+  describe :BUILTIN_EXCEPTIONS do
+    it "includes all base exceptions" do
+      YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
+        expect(eval(name)).to be <= Exception
+      end
     end
   end
 
-  it "should include all exceptions" do
-    YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
-      YARD::CodeObjects::BUILTIN_CLASSES.should include(name)
+  describe :BUILTIN_CLASSES do
+    it "includes all base classes" do
+      YARD::CodeObjects::BUILTIN_CLASSES.each do |name|
+        next if name == "MatchingData" && !defined?(::MatchingData)
+        next if name == "Continuation"
+        expect(eval(name)).to be_instance_of(Class)
+      end
+    end
+
+    it "includes all exceptions" do
+      YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
+        expect(YARD::CodeObjects::BUILTIN_CLASSES).to include(name)
+      end
     end
   end
-end
 
-describe YARD::CodeObjects, "BUILTIN_ALL" do
-  it "should include classes modules and exceptions" do
-    a = YARD::CodeObjects::BUILTIN_ALL
-    b = YARD::CodeObjects::BUILTIN_CLASSES
-    c = YARD::CodeObjects::BUILTIN_MODULES
-    a.should == b+c
+  describe :BUILTIN_ALL do
+    it "includes classes, modules, and exceptions" do
+      a = YARD::CodeObjects::BUILTIN_ALL
+      b = YARD::CodeObjects::BUILTIN_CLASSES
+      c = YARD::CodeObjects::BUILTIN_MODULES
+      expect(a).to eq b+c
+    end
   end
-end
 
-describe YARD::CodeObjects, "BUILTIN_MODULES" do
-  it "should include all base modules" do
-    YARD::CodeObjects::BUILTIN_MODULES.each do |name|
-      next if YARD.ruby19? && ["Precision"].include?(name)
-      eval(name).should be_instance_of(Module)
+  describe :BUILTIN_MODULES do
+    it "includes all base modules" do
+      YARD::CodeObjects::BUILTIN_MODULES.each do |name|
+        next if YARD.ruby19? && ["Precision"].include?(name)
+        expect(eval(name)).to be_instance_of(Module)
+      end
     end
   end
-end
+end

data/spec/code_objects/extra_file_object_spec.rb

@@ -1,147 +1,159 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::CodeObjects::ExtraFileObject do
-  describe '#initialize' do
-    it "should attempt to read contents from filesystem if contents=nil" do
-      File.should_receive(:read).with('file.txt').and_return('')
+  describe "#initialize" do
+    it "attempts to read contents from filesystem if contents=nil" do
+      expect(File).to receive(:read).with('file.txt').and_return('')
       ExtraFileObject.new('file.txt')
     end
 
-    it "should raise Errno::ENOENT if contents=nil and file does not exist" do
-      lambda { ExtraFileObject.new('file.txt') }.should raise_error(Errno::ENOENT)
+    it "raises Errno::ENOENT if contents=nil and file does not exist" do
+      expect { ExtraFileObject.new('file.txt') }.to raise_error(Errno::ENOENT)
     end
 
-    it "should not attempt to read from disk if contents are provided" do
+    it "does not attempt to read from disk if contents are provided" do
+      # TODO: no assertions here!
       ExtraFileObject.new('file.txt', 'CONTENTS')
     end
 
-    it "should set filename to filename" do
+    it "sets filename to filename" do
       file = ExtraFileObject.new('a/b/c/file.txt', 'CONTENTS')
-      file.filename.should == "a/b/c/file.txt"
+      expect(file.filename).to eq "a/b/c/file.txt"
     end
 
-    it "should parse out attributes at top of the file" do
+    it "parses out attributes at top of the file" do
       file = ExtraFileObject.new('file.txt', "# @title X\n# @some_attribute Y\nFOO BAR")
-      file.attributes[:title].should == "X"
-      file.attributes[:some_attribute].should == "Y"
-      file.contents.should == "FOO BAR"
+      expect(file.attributes[:title]).to eq "X"
+      expect(file.attributes[:some_attribute]).to eq "Y"
+      expect(file.contents).to eq "FOO BAR"
     end
 
-    it "should allow whitespace prior to '#' marker when parsing attributes" do
+    it "allows whitespace prior to '#' marker when parsing attributes" do
       file = ExtraFileObject.new('file.txt', " \t # @title X\nFOO BAR")
-      file.attributes[:title].should == "X"
-      file.contents.should == "FOO BAR"
+      expect(file.attributes[:title]).to eq "X"
+      expect(file.contents).to eq "FOO BAR"
     end
 
-    it "should parse out old-style #!markup shebang format" do
+    it "allows the attributes section to be wrapped in an HTML comment" do
+      file = ExtraFileObject.new('file.txt', "<!--\n# @title X\n-->\nFOO BAR")
+      expect(file.attributes[:title]).to eq "X"
+      expect(file.contents).to eq "FOO BAR"
+    end
+
+    it "allows whitespace around ignored HTML comment" do
+      file = ExtraFileObject.new('file.txt', " \t <!-- \n# @title X\n \t --> \nFOO BAR")
+      expect(file.attributes[:title]).to eq "X"
+      expect(file.contents).to eq "FOO BAR"
+    end
+
+    it "parses out old-style #!markup shebang format" do
       file = ExtraFileObject.new('file.txt', "#!foobar\nHello")
-      file.attributes[:markup].should == "foobar"
+      expect(file.attributes[:markup]).to eq "foobar"
     end
 
-    it "should not parse old-style #!markup if any whitespace is found" do
+    it "does not parse old-style #!markup if any whitespace is found" do
       file = ExtraFileObject.new('file.txt', " #!foobar\nHello")
-      file.attributes[:markup].should be_nil
-      file.contents.should == " #!foobar\nHello"
+      expect(file.attributes[:markup]).to be nil
+      expect(file.contents).to eq " #!foobar\nHello"
     end
 
-    it "should not parse out attributes if there are newlines prior to attributes" do
+    it "does not parse out attributes if there are newlines prior to attributes" do
       file = ExtraFileObject.new('file.txt', "\n# @title\nFOO BAR")
-      file.attributes.should be_empty
-      file.contents.should == "\n# @title\nFOO BAR"
+      expect(file.attributes).to be_empty
+      expect(file.contents).to eq "\n# @title\nFOO BAR"
     end
 
-    it "should set contents to data after attributes" do
+    it "sets contents to data after attributes" do
       file = ExtraFileObject.new('file.txt', "# @title\nFOO BAR")
-      file.contents.should == "FOO BAR"
+      expect(file.contents).to eq "FOO BAR"
     end
 
-    it "should preserve newlines" do
+    it "preserves newlines" do
       file = ExtraFileObject.new('file.txt', "FOO\r\nBAR\nBAZ")
-      file.contents.should == "FOO\r\nBAR\nBAZ"
+      expect(file.contents).to eq "FOO\r\nBAR\nBAZ"
     end
 
-    it "should not include newlines in attribute data" do
+    it "does not include newlines in attribute data" do
       file = ExtraFileObject.new('file.txt', "# @title FooBar\r\nHello world")
-      file.attributes[:title].should == "FooBar"
+      expect(file.attributes[:title]).to eq "FooBar"
     end
 
-    it "should force encoding to @encoding attribute if present" do
-      log.should_not_receive(:warn)
+    it "forces encoding to @encoding attribute if present" do
+      expect(log).not_to receive(:warn)
       data = "# @encoding sjis\nFOO"
       data.force_encoding('binary')
       file = ExtraFileObject.new('file.txt', data)
-      ['Shift_JIS', 'Windows-31J'].should include(file.contents.encoding.to_s)
+      expect(['Shift_JIS', 'Windows-31J']).to include(file.contents.encoding.to_s)
     end if YARD.ruby19?
 
-    it "should warn if @encoding is invalid" do
-      log.should_receive(:warn).with("Invalid encoding `INVALID' in file.txt")
+    it "warns if @encoding is invalid" do
+      expect(log).to receive(:warn).with("Invalid encoding `INVALID' in file.txt")
       data = "# @encoding INVALID\nFOO"
       encoding = data.encoding
       file = ExtraFileObject.new('file.txt', data)
-      file.contents.encoding.should == encoding
+      expect(file.contents.encoding).to eq encoding
     end if YARD.ruby19?
 
-    it "should ignore encoding in 1.8.x (or encoding-unaware platforms)" do
-      log.should_not_receive(:warn)
+    it "ignores encoding in 1.8.x (or encoding-unaware platforms)" do
+      expect(log).not_to receive(:warn)
       file = ExtraFileObject.new('file.txt', "# @encoding INVALID\nFOO")
     end if YARD.ruby18?
 
-    it "should attempt to re-parse data as 8bit ascii if parsing fails" do
-      log.should_not_receive(:warn)
+    it "attempts to re-parse data as 8-bit ascii if parsing fails" do
+      expect(log).not_to receive(:warn)
       str, out = *(["\xB0"] * 2)
       if str.respond_to?(:force_encoding)
         str.force_encoding('utf-8')
         out.force_encoding('binary')
       end
       file = ExtraFileObject.new('file.txt', str)
-      file.contents.should == out
+      expect(file.contents).to eq out
     end
   end
 
-  describe '#name' do
-    it "should be set to basename (not extension) of filename" do
+  describe "#name" do
+    it "returns basename (not extension) of filename" do
       file = ExtraFileObject.new('file.txt', '')
-      file.name.should == 'file'
+      expect(file.name).to eq 'file'
     end
   end
 
-  describe '#title' do
-    it "should return @title attribute if present" do
+  describe "#title" do
+    it "returns @title attribute if present" do
       file = ExtraFileObject.new('file.txt', '# @title FOO')
-      file.title.should == 'FOO'
+      expect(file.title).to eq 'FOO'
     end
 
-    it "should return #name if no @title attribute exists" do
+    it "returns #name if no @title attribute exists" do
       file = ExtraFileObject.new('file.txt', '')
-      file.title.should == 'file'
+      expect(file.title).to eq 'file'
     end
   end
 
-  describe '#locale=' do
-    it "should translate contents" do
+  describe "#locale=" do
+    it "translates contents" do
       file = ExtraFileObject.new('file.txt', 'Hello')
       file.locale = 'fr'
       fr_locale = I18n::Locale.new('fr')
       fr_messages = fr_locale.instance_variable_get(:@messages)
       fr_messages["Hello"] = 'Bonjour'
-      Registry.should_receive(:locale).with('fr').and_return(fr_locale)
-      file.contents.should == 'Bonjour'
+      expect(Registry).to receive(:locale).with('fr').and_return(fr_locale)
+      expect(file.contents).to eq 'Bonjour'
     end
   end
 
-  describe '#==' do
-    it "should define equality on filename alone" do
+  describe "#==" do
+    it "defines equality based on filename alone" do
       file1 = ExtraFileObject.new('file.txt', 'A')
       file2 = ExtraFileObject.new('file.txt', 'B')
-      file1.should == file2
-      file1.should be_eql(file2)
-      file1.should be_equal(file2)
+      expect(file1).to eq file2
+      expect(file1).to eql file2
+      expect(file1).to equal file2
 
       # Another way to test the equality interface
       a = [file1]
       a |= [file2]
-      a.size.should == 1
+      expect(a.size).to eq 1
     end
-
   end
 end