yard 0.8.7.6 → 0.9.0

data/spec/logging_spec.rb

@@ -1,32 +1,32 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
 describe YARD::Logger do
-  describe '#show_backtraces' do
-    it "should be true if debug level is on" do
+  describe "#show_backtraces" do
+    it "is true if debug level is on" do
       log.show_backtraces = true
       log.enter_level(Logger::DEBUG) do
         log.show_backtraces = false
-        log.show_backtraces.should == true
+        expect(log.show_backtraces).to be true
       end
-      log.show_backtraces.should == false
+      expect(log.show_backtraces).to be false
     end
   end
 
-  describe '#backtrace' do
+  describe "#backtrace" do
     before { log.show_backtraces = true }
-    after { log.show_backtraces = false }
+    after  { log.show_backtraces = false }
 
-    it "should log backtrace in error by default" do
-      log.should_receive(:error).with("RuntimeError: foo")
-      log.should_receive(:error).with("Stack trace:\n\tline1\n\tline2\n")
+    it "logs backtrace in error by default" do
+      expect(log).to receive(:error).with("RuntimeError: foo")
+      expect(log).to receive(:error).with("Stack trace:\n\tline1\n\tline2\n")
       exc = RuntimeError.new("foo")
       exc.set_backtrace(['line1', 'line2'])
       log.enter_level(Logger::INFO) { log.backtrace(exc) }
     end
 
-    it "should allow backtrace to be entered in other modes" do
-      log.should_receive(:warn).with("RuntimeError: foo")
-      log.should_receive(:warn).with("Stack trace:\n\tline1\n\tline2\n")
+    it "allows backtrace to be entered in other modes" do
+      expect(log).to receive(:warn).with("RuntimeError: foo")
+      expect(log).to receive(:warn).with("Stack trace:\n\tline1\n\tline2\n")
       exc = RuntimeError.new("foo")
       exc.set_backtrace(['line1', 'line2'])
       log.enter_level(Logger::INFO) { log.backtrace(exc, :warn) }

data/spec/options_spec.rb

@@ -6,38 +6,38 @@ describe YARD::Options do
     def initialize; self.foo = "abc" end
   end
 
-  describe '.default_attr' do
-    it "should allow default attributes to be defined with symbols" do
+  describe ".default_attr" do
+    it "allows default attributes to be defined with symbols" do
       class DefaultOptions1 < YARD::Options
         default_attr :foo, 'HELLO'
       end
       o = DefaultOptions1.new
       o.reset_defaults
-      o.foo.should == 'HELLO'
+      expect(o.foo).to eq 'HELLO'
     end
 
-    it "should call lambda if value is a Proc" do
+    it "calls lambda if value is a Proc" do
       class DefaultOptions2 < YARD::Options
         default_attr :foo, lambda { 100 }
       end
       o = DefaultOptions2.new
       o.reset_defaults
-      o.foo.should == 100
+      expect(o.foo).to eq 100
     end
   end
 
-  describe '#reset_defaults' do
-    it "should not define defaults until reset is called" do
+  describe "#reset_defaults" do
+    it "does not define defaults until reset is called" do
       class ResetDefaultOptions1 < YARD::Options
         default_attr :foo, 'FOO'
       end
-      ResetDefaultOptions1.new.foo.should be_nil
+      expect(ResetDefaultOptions1.new.foo).to be nil
       o = ResetDefaultOptions1.new
       o.reset_defaults
-      o.foo.should == 'FOO'
+      expect(o.foo).to eq 'FOO'
     end
 
-    it "should use defaults from superclass as well" do
+    it "uses defaults from superclass as well" do
       class ResetDefaultOptions2 < YARD::Options
         default_attr :foo, 'FOO'
       end
@@ -45,127 +45,127 @@ describe YARD::Options do
       end
       o = ResetDefaultOptions3.new
       o.reset_defaults
-      o.foo.should == 'FOO'
+      expect(o.foo).to eq 'FOO'
     end
   end
 
-  describe '#delete' do
-    it "should delete an option" do
+  describe "#delete" do
+    it "deletes an option" do
       o = FooOptions.new
       o.delete(:foo)
-      o.to_hash.should == {}
+      expect(o.to_hash).to eq({})
     end
 
-    it "should not error if an option is deleted that does not exist" do
+    it "does not error if an option is deleted that does not exist" do
       o = FooOptions.new
       o.delete(:foo)
       o.delete(:foo)
-      o.to_hash.should == {}
+      expect(o.to_hash).to eq({})
     end
   end
 
-  describe '#[]' do
-    it "should handle getting option values using hash syntax" do
-      FooOptions.new[:foo].should == "abc"
+  describe "#[]" do
+    it "handles getting option values using hash syntax" do
+      expect(FooOptions.new[:foo]).to eq "abc"
     end
   end
 
-  describe '#[]=' do
-    it "should handle setting options using hash syntax" do
+  describe "#[]=" do
+    it "handles setting options using hash syntax" do
       o = FooOptions.new
       o[:foo] = "xyz"
-      o[:foo].should == "xyz"
+      expect(o[:foo]).to eq "xyz"
     end
 
-    it "should allow setting of unregistered keys" do
+    it "allows setting of unregistered keys" do
       o = FooOptions.new
       o[:bar] = "foo"
-      o[:bar].should == "foo"
+      expect(o[:bar]).to eq "foo"
     end
   end
 
-  describe '#method_missing' do
-    it "should allow setting of unregistered keys" do
+  describe "#method_missing" do
+    it "allows setting of unregistered keys" do
       o = FooOptions.new
       o.bar = 'foo'
-      o.bar.should == 'foo'
+      expect(o.bar).to eq 'foo'
     end
 
-    it "should allow getting values of unregistered keys (return nil)" do
-      FooOptions.new.bar.should be_nil
+    it "allows getting values of unregistered keys (return nil)" do
+      expect(FooOptions.new.bar).to be nil
     end
 
-    it "should print debugging messages about unregistered keys" do
-      log.should_receive(:debug).with("Attempting to access unregistered key bar on FooOptions")
+    it "prints debugging messages about unregistered keys" do
+      expect(log).to receive(:debug).with("Attempting to access unregistered key bar on FooOptions")
       FooOptions.new.bar
-      log.should_receive(:debug).with("Attempting to set unregistered key bar on FooOptions")
+      expect(log).to receive(:debug).with("Attempting to set unregistered key bar on FooOptions")
       FooOptions.new.bar = 1
     end
   end
 
-  describe '#update' do
-    it "should allow updating of options" do
-      FooOptions.new.update(:foo => "xyz").foo.should == "xyz"
+  describe "#update" do
+    it "allows updating of options" do
+      expect(FooOptions.new.update(:foo => "xyz").foo).to eq "xyz"
     end
 
-    it "should not ignore keys with no setter (OpenStruct behaviour)" do
+    it "does not ignore keys with no setter (OpenStruct behaviour)" do
       o = FooOptions.new
       o.update(:bar => "xyz")
-      o.to_hash.should == {:foo => "abc", :bar => "xyz"}
+      expect(o.to_hash).to eq({:foo => "abc", :bar => "xyz"})
     end
   end
 
-  describe '#merge' do
-    it "should update a new object" do
+  describe "#merge" do
+    it "updates a new object" do
       o = FooOptions.new
-      o.merge(:foo => "xyz").object_id.should_not == o.object_id
-      o.merge(:foo => "xyz").to_hash.should == {:foo => "xyz"}
+      expect(o.merge(:foo => "xyz").object_id).not_to eq o.object_id
+      expect(o.merge(:foo => "xyz").to_hash).to eq({:foo => "xyz"})
     end
 
-    it "should add in values from original object" do
+    it "adds in values from original object" do
       o = FooOptions.new
       o.update(:bar => "foo")
-      o.merge(:baz => 1).to_hash.should == {:foo => "abc", :bar => "foo", :baz => 1}
+      expect(o.merge(:baz => 1).to_hash).to eq({:foo => "abc", :bar => "foo", :baz => 1})
     end
   end
 
-  describe '#to_hash' do
-    it "should convert all instance variables and symbolized keys" do
+  describe "#to_hash" do
+    it "converts all instance variables and symbolized keys" do
       class ToHashOptions1 < YARD::Options
         attr_accessor :foo, :bar, :baz
         def initialize; @foo = 1; @bar = 2; @baz = "hello" end
       end
       o = ToHashOptions1.new
       hash = o.to_hash
-      hash.keys.should include(:foo, :bar, :baz)
-      hash[:foo].should == 1
-      hash[:bar].should == 2
-      hash[:baz].should == "hello"
+      expect(hash.keys).to include(:foo, :bar, :baz)
+      expect(hash[:foo]).to eq 1
+      expect(hash[:bar]).to eq 2
+      expect(hash[:baz]).to eq "hello"
     end
 
-    it "should use accessor when converting values to hash" do
+    it "uses accessor when converting values to hash" do
       class ToHashOptions2 < YARD::Options
         def initialize; @foo = 1 end
         def foo; "HELLO#{@foo}" end
       end
       o = ToHashOptions2.new
-      o.to_hash.should == {:foo => "HELLO1"}
+      expect(o.to_hash).to eq({:foo => "HELLO1"})
     end
 
-    it "should ignore ivars with no accessor" do
+    it "ignores ivars with no accessor" do
       class ToHashOptions3 < YARD::Options
         attr_accessor :foo
         def initialize; @foo = 1; @bar = "NOIGNORE" end
       end
       o = ToHashOptions3.new
-      o.to_hash.should == {:foo => 1, :bar => "NOIGNORE"}
+      expect(o.to_hash).to eq({:foo => 1, :bar => "NOIGNORE"})
     end
   end
 
-  describe '#tap' do
-    it "should support #tap(&block) (even in 1.8.6)" do
+  describe "#tap" do
+    it "supports #tap(&block) (even in 1.8.6)" do
       o = FooOptions.new.tap {|o| o.foo = :BAR }
-      o.to_hash.should == {:foo => :BAR}
+      expect(o.to_hash).to eq({:foo => :BAR})
     end
   end
 end

data/spec/parser/base_spec.rb

@@ -1,24 +1,24 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe YARD::Parser::Base do
-  describe '#initialize' do
+  describe "#initialize" do
     class MyParser < Parser::Base; def initialize(a, b) end end
 
-    it "should take 2 arguments" do
-      lambda { YARD::Parser::Base.new }.should raise_error(ArgumentError,
+    it "takes 2 arguments" do
+      expect { YARD::Parser::Base.new }.to raise_error(ArgumentError,
         /wrong (number|#) of arguments|given 0, expected 2/)
     end
 
-    it "should raise NotImplementedError on #initialize" do
-      lambda { YARD::Parser::Base.new('a', 'b') }.should raise_error(NotImplementedError)
+    it "raises NotImplementedError on #initialize" do
+      expect { YARD::Parser::Base.new('a', 'b') }.to raise_error(NotImplementedError)
     end
 
-    it "should raise NotImplementedError on #parse" do
-      lambda { MyParser.new('a', 'b').parse }.should raise_error(NotImplementedError)
+    it "raises NotImplementedError on #parse" do
+      expect { MyParser.new('a', 'b').parse }.to raise_error(NotImplementedError)
     end
 
-    it "should raise NotImplementedError on #tokenize" do
-      lambda { MyParser.new('a', 'b').tokenize }.should raise_error(NotImplementedError)
+    it "raises NotImplementedError on #tokenize" do
+      expect { MyParser.new('a', 'b').tokenize }.to raise_error(NotImplementedError)
     end
   end
 end

data/spec/parser/c_parser_spec.rb

@@ -1,60 +1,60 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe YARD::Parser::C::CParser do
-  describe '#parse' do
+  describe "#parse" do
     def parse(contents)
       Registry.clear
       YARD.parse_string(contents, :c)
     end
 
-    describe 'Array class' do
+    describe "Array class" do
       before(:all) do
         file = File.join(File.dirname(__FILE__), 'examples', 'array.c.txt')
         parse(File.read(file))
       end
 
-      it "should parse Array class" do
+      it "parses Array class" do
         obj = YARD::Registry.at('Array')
-        obj.should_not be_nil
-        obj.docstring.should_not be_blank
+        expect(obj).not_to be nil
+        expect(obj.docstring).not_to be_blank
       end
 
-      it "should parse method" do
+      it "parses method" do
         obj = YARD::Registry.at('Array#initialize')
-        obj.docstring.should_not be_blank
-        obj.tags(:overload).size.should > 1
+        expect(obj.docstring).not_to be_blank
+        expect(obj.tags(:overload).size).to be > 1
       end
     end
 
-    describe 'Source located in extra files' do
+    describe "Source located in extra files" do
       before(:all) do
         @multifile = File.join(File.dirname(__FILE__), 'examples', 'multifile.c.txt')
         @extrafile = File.join(File.dirname(__FILE__), 'examples', 'extrafile.c.txt')
         @contents = File.read(@multifile)
       end
 
-      it "should look for methods in extra files (if 'in' comment is found)" do
+      it "looks for methods in extra files (if 'in' comment is found)" do
         extra_contents = File.read(@extrafile)
-        File.should_receive(:read).with('extra.c').and_return(extra_contents)
+        expect(File).to receive(:read).with('extra.c').and_return(extra_contents)
         parse(@contents)
-        Registry.at('Multifile#extra').docstring.should == 'foo'
+        expect(Registry.at('Multifile#extra').docstring).to eq 'foo'
       end
 
-      it "should stop searching for extra source file gracefully if file is not found" do
-        File.should_receive(:read).with('extra.c').and_raise(Errno::ENOENT)
-        log.should_receive(:warn).with("Missing source file `extra.c' when parsing Multifile#extra")
+      it "stops searching for extra source file gracefully if file is not found" do
+        expect(File).to receive(:read).with('extra.c').and_raise(Errno::ENOENT)
+        expect(log).to receive(:warn).with("Missing source file `extra.c' when parsing Multifile#extra")
         parse(@contents)
-        Registry.at('Multifile#extra').docstring.should == ''
+        expect(Registry.at('Multifile#extra').docstring).to eq ''
       end
 
-      it "should differentiate between a struct and a pointer to a struct retval" do
+      it "differentiates between a struct and a pointer to a struct retval" do
         parse(@contents)
-        Registry.at('Multifile#hello_mars').docstring.should == 'Hello Mars'
+        expect(Registry.at('Multifile#hello_mars').docstring).to eq 'Hello Mars'
       end
     end
 
-    describe 'Foo class' do
-      it 'should not include comments in docstring source' do
+    describe "Foo class" do
+      it "does not include comments in docstring source" do
         parse <<-eof
           /*
            * Hello world
@@ -67,13 +67,13 @@ describe YARD::Parser::C::CParser do
             rb_define_method(rb_cFoo, "foo", foo, 1);
           }
         eof
-        Registry.at('Foo#foo').source.gsub(/\s\s+/, ' ').should ==
-          "VALUE foo(VALUE x) { int value = x;\n}"
+        expect(Registry.at('Foo#foo').source.gsub(/\s\s+/, ' ')).to eq(
+          "VALUE foo(VALUE x) { int value = x;\n}")
       end
     end
 
-    describe 'Constant' do
-      it 'should not truncate docstring' do
+    describe "Constant" do
+      it "does not truncate docstring" do
         parse <<-eof
           #define MSK_DEADBEEF 0xdeadbeef
           void
@@ -86,13 +86,13 @@ describe YARD::Parser::C::CParser do
           }
         eof
         constant = Registry.at('Mask::DEADBEEF')
-        constant.value.should == '0xdeadbeef'
-        constant.docstring.should == "This constant is frequently used to indicate a\nsoftware crash or deadlock in embedded systems."
+        expect(constant.value).to eq '0xdeadbeef'
+        expect(constant.docstring).to eq "This constant is frequently used to indicate a\nsoftware crash or deadlock in embedded systems."
       end
     end
 
-    describe 'Macros' do
-      it "should handle param## inside of macros" do
+    describe "Macros" do
+      it "handles param## inside of macros" do
         thr = Thread.new do
           parse <<-eof
           void
@@ -127,8 +127,8 @@ describe YARD::Parser::C::CParser do
       end
     end
 
-    describe 'C macros in declaration' do
-      it "should handle C macros in method declaration" do
+    describe "C macros in declaration" do
+      it "handles C macros in method declaration" do
         Registry.clear
         parse <<-eof
         // docstring
@@ -141,49 +141,49 @@ describe YARD::Parser::C::CParser do
         }
         eof
 
-        Registry.at('Foo#func').docstring.should == "docstring"
+        expect(Registry.at('Foo#func').docstring).to eq "docstring"
       end
     end
   end
 
-  describe 'Override comments' do
+  describe "Override comments" do
     before(:all) do
       Registry.clear
       override_file = File.join(File.dirname(__FILE__), 'examples', 'override.c.txt')
       @override_parser = YARD.parse_string(File.read(override_file), :c)
     end
 
-    it "should parse GMP::Z class" do
+    it "parses GMP::Z class" do
       z = YARD::Registry.at('GMP::Z')
-      z.should_not be_nil
-      z.docstring.should_not be_blank
+      expect(z).not_to be nil
+      expect(z.docstring).not_to be_blank
     end
 
-    it "should parse GMP::Z methods w/ bodies" do
+    it "parses GMP::Z methods w/ bodies" do
       add = YARD::Registry.at('GMP::Z#+')
-      add.docstring.should_not be_blank
-      add.source.should_not be_nil
-      add.source.should_not be_empty
+      expect(add.docstring).not_to be_blank
+      expect(add.source).not_to be nil
+      expect(add.source).not_to be_empty
 
       add_self = YARD::Registry.at('GMP::Z#+')
-      add_self.docstring.should_not be_blank
-      add_self.source.should_not be_nil
-      add_self.source.should_not be_empty
+      expect(add_self.docstring).not_to be_blank
+      expect(add_self.source).not_to be nil
+      expect(add_self.source).not_to be_empty
 
       sqrtrem = YARD::Registry.at('GMP::Z#+')
-      sqrtrem.docstring.should_not be_blank
-      sqrtrem.source.should_not be_nil
-      sqrtrem.source.should_not be_empty
+      expect(sqrtrem.docstring).not_to be_blank
+      expect(sqrtrem.source).not_to be nil
+      expect(sqrtrem.source).not_to be_empty
     end
 
-    it "should parse GMP::Z methods w/o bodies" do
+    it "parses GMP::Z methods w/o bodies" do
       neg = YARD::Registry.at('GMP::Z#neg')
-      neg.docstring.should_not be_blank
-      neg.source.should be_nil
+      expect(neg.docstring).not_to be_blank
+      expect(neg.source).to be nil
 
       neg_self = YARD::Registry.at('GMP::Z#neg')
-      neg_self.docstring.should_not be_blank
-      neg_self.source.should be_nil
+      expect(neg_self.docstring).not_to be_blank
+      expect(neg_self.source).to be nil
     end
   end
 end