yard 0.8.7.6 → 0.9.0

data/spec/handlers/alias_handler_spec.rb

@@ -3,77 +3,77 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AliasHandler" do
   before(:all) { parse_file :alias_handler_001, __FILE__ }
 
-  it "should throw alias into namespace object list" do
-    P(:A).aliases[P("A#b")].should == :a
+  it "throws alias into namespace object list" do
+    expect(P(:A).aliases[P("A#b")]).to eq :a
   end
 
   ['c', 'd?', '[]', '[]=', '-@', '%', '*', 'cstrkey', 'cstrmeth'].each do |a|
-    it "should handle the Ruby 'alias' keyword syntax for method ##{a}" do
-      P('A#' + a).should be_instance_of(CodeObjects::MethodObject)
-      P('A#' + a).is_alias?.should be_true
+    it "handles the Ruby 'alias' keyword syntax for method ##{a}" do
+      expect(P('A#' + a)).to be_instance_of(CodeObjects::MethodObject)
+      expect(P('A#' + a).is_alias?).to be true
     end
   end
 
-  it "should handle keywords as the alias name" do
-    P('A#for').should be_instance_of(CodeObjects::MethodObject)
+  it "handles keywords as the alias name" do
+    expect(P('A#for')).to be_instance_of(CodeObjects::MethodObject)
   end
 
-  it "should allow ConstantNames to be specified as aliases" do
-    P('A#ConstantName').should be_instance_of(CodeObjects::MethodObject)
+  it "allows ConstantNames to be specified as aliases" do
+    expect(P('A#ConstantName')).to be_instance_of(CodeObjects::MethodObject)
   end
 
-  it "should create a new method object for the alias" do
-    P("A#b").should be_instance_of(CodeObjects::MethodObject)
+  it "creates a new method object for the alias" do
+    expect(P("A#b")).to be_instance_of(CodeObjects::MethodObject)
   end
 
-  it "should pull the method into the current class if it's from another one" do
-    P(:B).aliases[P("B#q")].should == :x
-    P(:B).aliases[P("B#r?")].should == :x
+  it "pulls the method into the current class if it's from another one" do
+    expect(P(:B).aliases[P("B#q")]).to eq :x
+    expect(P(:B).aliases[P("B#r?")]).to eq :x
   end
 
-  it "should gracefully fail to pull a method in if the original method cannot be found" do
-    P(:B).aliases[P("B#s")].should == :to_s
+  it "gracefully fails to pull a method in if the original method cannot be found" do
+    expect(P(:B).aliases[P("B#s")]).to eq :to_s
   end
 
-  it "should allow complex Ruby expressions after the alias parameters" do
-    P(:B).aliases[P("B#t")].should == :inspect
+  it "allows complex Ruby expressions after the alias parameters" do
+    expect(P(:B).aliases[P("B#t")]).to eq :inspect
   end
 
-  it "should show up in #is_alias? for method" do
-    P("B#t").is_alias?.should == true
-    P('B#r?').is_alias?.should == true
+  it "shows up in #is_alias? for method" do
+    expect(P("B#t").is_alias?).to be true
+    expect(P('B#r?').is_alias?).to be true
   end
 
-  it "should allow operators and keywords to be specified as symbols" do
-    P('B#<<').should be_instance_of(CodeObjects::MethodObject)
-    P('B#for').should be_instance_of(CodeObjects::MethodObject)
+  it "allows operators and keywords to be specified as symbols" do
+    expect(P('B#<<')).to be_instance_of(CodeObjects::MethodObject)
+    expect(P('B#for')).to be_instance_of(CodeObjects::MethodObject)
   end
 
-  it "should handle keywords in alias names" do
-    P('B#do').is_alias?.should == true
-    P('B#x2').is_alias?.should == true
-    P(:B).aliases[P('B#do')].should == :x
-    P(:B).aliases[P('B#x2')].should == :do
+  it "handles keywords in alias names" do
+    expect(P('B#do').is_alias?).to be true
+    expect(P('B#x2').is_alias?).to be true
+    expect(P(:B).aliases[P('B#do')]).to eq :x
+    expect(P(:B).aliases[P('B#x2')]).to eq :do
   end
 
-  it "should handle quoted symbols" do
+  it "handles quoted symbols" do
     foo = Registry.at('A#foo')
-    foo.should_not be_nil
-    foo.should be_is_alias
-    Registry.at('A').aliases[foo].should == :a
+    expect(foo).not_to be nil
+    expect(foo.is_alias?).to be true
+    expect(Registry.at('A').aliases[foo]).to eq :a
   end
 
-  it "should prepend aliases object's docstring to comments" do
-    Registry.at('D#a').tag(:return).types.should == ['Numeric']
-    Registry.at('D#b').tag(:return).types.should == ['String']
-    Registry.at('D#b').docstring.should == "Foo bar"
+  it "prepends aliases object's docstring to comments" do
+    expect(Registry.at('D#a').tag(:return).types).to eq ['Numeric']
+    expect(Registry.at('D#b').tag(:return).types).to eq ['String']
+    expect(Registry.at('D#b').docstring).to eq "Foo bar"
   end
 
-  it "should raise an UndocumentableError if only one parameter is passed" do
+  it "raises an UndocumentableError if only one parameter is passed" do
     undoc_error "alias_method :q"
   end
 
-  it "should raise an UndocumentableError if the parameter is not a Symbol or String" do
+  it "raises an UndocumentableError if the parameter is not a Symbol or String" do
     undoc_error "alias_method CONST, Something"
     undoc_error "alias_method variable, ClassName"
     undoc_error "alias_method variable, other_variable"

data/spec/handlers/attribute_handler_spec.rb

@@ -6,89 +6,89 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AttributeHandl
   def read_write(namespace, name, read, write, scope = :instance)
     rname, wname = namespace.to_s+"#"+name.to_s, namespace.to_s+"#"+name.to_s+"="
     if read
-      Registry.at(rname).should be_instance_of(CodeObjects::MethodObject)
+      expect(Registry.at(rname)).to be_instance_of(CodeObjects::MethodObject)
     else
-      Registry.at(rname).should == nil
+      expect(Registry.at(rname)).to eq nil
     end
 
     if write
-      Registry.at(wname).should be_kind_of(CodeObjects::MethodObject)
+      expect(Registry.at(wname)).to be_kind_of(CodeObjects::MethodObject)
     else
-      Registry.at(wname).should == nil
+      expect(Registry.at(wname)).to eq nil
     end
 
     attrs = Registry.at(namespace).attributes[scope][name]
-    attrs[:read].should == (read ? Registry.at(rname) : nil)
-    attrs[:write].should == (write ? Registry.at(wname) : nil)
+    expect(attrs[:read]).to eq (read ? Registry.at(rname) : nil)
+    expect(attrs[:write]).to eq (write ? Registry.at(wname) : nil)
   end
 
-  it "should parse attributes inside modules too" do
-    Registry.at("A#x=").should_not == nil
+  it "parses attributes inside modules too" do
+    expect(Registry.at("A#x=")).not_to eq nil
   end
 
-  it "should parse 'attr'" do
+  it "parses 'attr'" do
     read_write(:B, :a, true, true)
     read_write(:B, :a2, true, false)
     read_write(:B, "a3", true, false)
   end
 
-  it "should parse 'attr_reader'" do
+  it "parses 'attr_reader'" do
     read_write(:B, :b, true, false)
   end
 
-  it "should parse 'attr_writer'" do
+  it "parses 'attr_writer'" do
     read_write(:B, :e, false, true)
   end
 
-  it "should parse 'attr_accessor'" do
+  it "parses 'attr_accessor'" do
     read_write(:B, :f, true, true)
   end
 
-  it "should parse a list of attributes" do
+  it "parses a list of attributes" do
     read_write(:B, :b, true, false)
     read_write(:B, :c, true, false)
     read_write(:B, :d, true, false)
   end
 
-  it "should have a default docstring if one is not supplied" do
-    Registry.at("B#f=").docstring.should_not be_empty
+  it "has a default docstring if one is not supplied" do
+    expect(Registry.at("B#f=").docstring).not_to be_empty
   end
 
-  it "should set the correct docstring if one is supplied" do
-    Registry.at("B#b").docstring.should == "Docstring"
-    Registry.at("B#c").docstring.should == "Docstring"
-    Registry.at("B#d").docstring.should == "Docstring"
+  it "sets the correct docstring if one is supplied" do
+    expect(Registry.at("B#b").docstring).to eq "Docstring"
+    expect(Registry.at("B#c").docstring).to eq "Docstring"
+    expect(Registry.at("B#d").docstring).to eq "Docstring"
   end
 
-  it "should be able to differentiate between class and instance attributes" do
-    P('B').class_attributes[:z][:read].scope.should == :class
-    P('B').instance_attributes[:z][:read].scope.should == :instance
+  it "is able to differentiate between class and instance attributes" do
+    expect(P('B').class_attributes[:z][:read].scope).to eq :class
+    expect(P('B').instance_attributes[:z][:read].scope).to eq :instance
   end
 
-  it "should respond true in method's #is_attribute?" do
-    P('B#a').is_attribute?.should == true
-    P('B#a=').is_attribute?.should == true
+  it "responds true in method's #is_attribute?" do
+    expect(P('B#a').is_attribute?).to be true
+    expect(P('B#a=').is_attribute?).to be true
   end
 
-  it "should not return true for #is_explicit? in created methods" do
+  it "does not return true for #is_explicit? in created methods" do
     Registry.at(:B).meths.each do |meth|
-      meth.is_explicit?.should == false
+      expect(meth.is_explicit?).to be false
     end
   end
 
-  it "should handle attr call with no arguments" do
-    lambda { StubbedSourceParser.parse_string "attr" }.should_not raise_error
+  it "handles attr call with no arguments" do
+    expect { StubbedSourceParser.parse_string "attr" }.not_to raise_error
   end
 
-  it "should add existing reader method as part of attr_writer combo" do
-    Registry.at('C#foo=').attr_info[:read].should == Registry.at('C#foo')
+  it "adds existing reader method as part of attr_writer combo" do
+    expect(Registry.at('C#foo=').attr_info[:read]).to eq Registry.at('C#foo')
   end
 
-  it "should add existing writer method as part of attr_reader combo" do
-    Registry.at('C#foo').attr_info[:write].should == Registry.at('C#foo=')
+  it "adds existing writer method as part of attr_reader combo" do
+    expect(Registry.at('C#foo').attr_info[:write]).to eq Registry.at('C#foo=')
   end
 
-  it "should maintain visibility for attr_reader" do
-    Registry.at('D#parser').visibility.should == :protected
+  it "maintains visibility for attr_reader" do
+    expect(Registry.at('D#parser').visibility).to eq :protected
   end
 end

data/spec/handlers/base_spec.rb

@@ -6,51 +6,51 @@ include Parser
 describe YARD::Handlers::Base do
   describe "#handles and inheritance" do
     before do
-      Handlers::Base.stub!(:inherited)
+      allow(Handlers::Base).to receive(:inherited)
     end
 
-    it "should keep track of subclasses" do
-      Handlers::Base.should_receive(:inherited).once
+    it "keeps track of subclasses" do
+      expect(Handlers::Base).to receive(:inherited).once
       class TestHandler < Handlers::Base; end
     end
 
-    it "should raise NotImplementedError if process is called on a class with no #process" do
+    it "raises NotImplementedError if process is called on a class with no #process" do
       class TestNotImplementedHandler < Handlers::Base
       end
 
-      lambda { TestNotImplementedHandler.new(0, 0).process }.should raise_error(NotImplementedError)
+      expect { TestNotImplementedHandler.new(0, 0).process }.to raise_error(NotImplementedError)
     end
 
-    it "should allow multiple handles arguments" do
-      Handlers::Base.should_receive(:inherited).once
+    it "allows multiple handles arguments" do
+      expect(Handlers::Base).to receive(:inherited).once
       class TestHandler1 < Handlers::Base
         handles :a, :b, :c
       end
-      TestHandler1.handlers.should == [:a, :b, :c]
+      expect(TestHandler1.handlers).to eq [:a, :b, :c]
     end
 
-    it "should allow multiple handles calls" do
-      Handlers::Base.should_receive(:inherited).once
+    it "allows multiple handles calls" do
+      expect(Handlers::Base).to receive(:inherited).once
       class TestHandler2 < Handlers::Base
         handles :a
         handles :b
         handles :c
       end
-      TestHandler2.handlers.should == [:a, :b, :c]
+      expect(TestHandler2.handlers).to eq [:a, :b, :c]
     end
   end
 
-  describe '#abort! (and HandlerAborted)' do
-    it 'should allow HandlerAborted to be raised' do
+  describe "#abort! (and HandlerAborted)" do
+    it "allows HandlerAborted to be raised" do
       class AbortHandler1 < Handlers::Ruby::Base
         process { abort! }
       end
-      lambda { AbortHandler1.new(nil, nil).process }.should raise_error(HandlerAborted)
+      expect { AbortHandler1.new(nil, nil).process }.to raise_error(HandlerAborted)
     end
   end
 
-  describe 'transitive tags' do
-    it "should add transitive tags to children" do
+  describe "transitive tags" do
+    it "adds transitive tags to children" do
       Registry.clear
       YARD.parse_string <<-eof
         # @since 1.0
@@ -61,15 +61,15 @@ describe YARD::Handlers::Base do
           def bar; end
         end
       eof
-      Registry.at('A').tag(:since).text.should == "1.0"
-      Registry.at('A#foo').tag(:since).text.should == "1.0"
-      Registry.at('A#bar').tag(:since).text.should == "1.1"
-      Registry.at('A#bar').tag(:author).should be_nil
+      expect(Registry.at('A').tag(:since).text).to eq "1.0"
+      expect(Registry.at('A#foo').tag(:since).text).to eq "1.0"
+      expect(Registry.at('A#bar').tag(:since).text).to eq "1.1"
+      expect(Registry.at('A#bar').tag(:author)).to be nil
     end
   end
 
-  describe 'sharing global state' do
-    it "should allow globals to share global state among handlers" do
+  describe "sharing global state" do
+    it "allows globals to share global state among handlers" do
       class GlobalStateHandler1 < Handlers::Ruby::Base
         class << self; attr_accessor :state end
         handles :class
@@ -84,64 +84,73 @@ describe YARD::Handlers::Base do
 
       2.times do
         YARD.parse_string 'class Foo; end; def foo; end'
-        GlobalStateHandler1.state.should == nil
-        GlobalStateHandler2.state.should == :bar
+        expect(GlobalStateHandler1.state).to eq nil
+        expect(GlobalStateHandler2.state).to eq :bar
       end
     end
   end if HAVE_RIPPER
 
-  describe '#push_state' do
+  describe "#push_state" do
     def process(klass)
       state = OpenStruct.new(:namespace => "ROOT", :scope => :instance, :owner => "ROOT")
       klass.new(state, nil).process
     end
 
-    it "should push and return all old state info after block" do
+    it "pushes and return all old state info after block" do
       class PushStateHandler1 < Handlers::Base
+        include RSpec::Matchers
+        RSpec::Expectations::Syntax.enable_expect(self)
+
         def process
           push_state(:namespace => "FOO", :scope => :class, :owner => "BAR") do
-            namespace.should == "FOO"
-            scope.should == :class
-            owner.should == "BAR"
+            expect(namespace).to eq "FOO"
+            expect(scope).to eq :class
+            expect(owner).to eq "BAR"
           end
-          namespace.should == "ROOT"
-          owner.should == "ROOT"
-          scope.should == :instance
+          expect(namespace).to eq "ROOT"
+          expect(owner).to eq "ROOT"
+          expect(scope).to eq :instance
         end
       end
       process PushStateHandler1
     end
 
-    it "should allow owner to be pushed individually" do
+    it "allows owner to be pushed individually" do
       class PushStateHandler2 < Handlers::Base
+        include RSpec::Matchers
+        RSpec::Expectations::Syntax.enable_expect(self)
+
         def process
           push_state(:owner => "BAR") do
-            namespace.should == "ROOT"
-            scope.should == :instance
-            owner.should == "BAR"
+            expect(namespace).to eq "ROOT"
+            expect(scope).to eq :instance
+            expect(owner).to eq "BAR"
           end
-          owner.should == "ROOT"
+          expect(owner).to eq "ROOT"
         end
       end
       process PushStateHandler2
     end
 
-    it "should allow scope to be pushed individually" do
+    it "allows scope to be pushed individually" do
       class PushStateHandler3 < Handlers::Base
+        include RSpec::Matchers
+        RSpec::Expectations::Syntax.enable_expect(self)
+
         def process
           push_state(:scope => :foo) do
-            namespace.should == "ROOT"
-            scope.should == :foo
-            owner.should == "ROOT"
+            expect(namespace).to eq "ROOT"
+            expect(scope).to eq :foo
+            expect(owner).to eq "ROOT"
           end
-          scope.should == :instance
+          expect(scope).to eq :instance
         end
       end
       process PushStateHandler3
     end
   end
 
-  describe '.in_file' do
+  describe ".in_file" do
     def parse(filename, parser_type, src = "class A; end")
       parser = Parser::SourceParser.new(parser_type)
       parser.instance_variable_set("@file", filename)
@@ -162,39 +171,39 @@ describe YARD::Handlers::Base do
 
     def test_handler(file, stmts, creates = true, parser_type = :ruby)
       Registry.clear
-      Registry.at('#FOO').should be_nil
+      expect(Registry.at('#FOO')).to be nil
       create_handler(stmts, parser_type)
       parse(file, parser_type)
-      Registry.at('#FOO').send(creates ? :should_not : :should, be_nil)
+      expect(Registry.at('#FOO')).send(creates ? :not_to : :to, be_nil)
       Handlers::Base.subclasses.delete_if {|k,v| k.to_s =~ /^InFileHandler/ }
     end
 
     [:ruby, :ruby18].each do |parser_type|
       next if parser_type == :ruby && LEGACY_PARSER
       describe "Parser type = #{parser_type.inspect}" do
-        it "should allow handler to be specific to a file" do
+        it "allows handler to be specific to a file" do
           test_handler 'file_a.rb', 'in_file "file_a.rb"', true, parser_type
         end
 
-        it "should ignore handler if filename does not match" do
+        it "ignores handler if filename does not match" do
           test_handler 'file_b.rb', 'in_file "file_a.rb"', false, parser_type
         end
 
-        it "should only test filename part when given a String" do
+        it "only tests filename part when given a String" do
           test_handler '/path/to/file_a.rb', 'in_file "/to/file_a.rb"', false, parser_type
         end
 
-        it "should test exact match for entire String" do
+        it "tests exact match for entire String" do
           test_handler 'file_a.rb', 'in_file "file"', false, parser_type
         end
 
-        it "should allow a Regexp as argument and test against full path" do
+        it "allows a Regexp as argument and test against full path" do
           test_handler 'file_a.rbx', 'in_file /\.rbx$/', true, parser_type
           test_handler '/path/to/file_a.rbx', 'in_file /\/to\/file_/', true, parser_type
           test_handler '/path/to/file_a.rbx', 'in_file /^\/path/', true, parser_type
         end
 
-        it "should allow multiple in_file declarations" do
+        it "allows multiple in_file declarations" do
           stmts = 'in_file "x"; in_file /y/; in_file "foo.rb"'
           test_handler 'foo.rb', stmts, true, parser_type
           test_handler 'xyzzy.rb', stmts, true, parser_type