yard 0.2.3.5 → 0.4.0

data/spec/code_objects/method_object_spec.rb

@@ -46,13 +46,13 @@ describe YARD::CodeObjects::MethodObject do
   describe '#name' do
     it "should show a prefix for an instance method when prefix=true" do
       obj = MethodObject.new(nil, :something)
-      obj.name(true).should == :"#something"
+      obj.name(true).should == "#something"
     end
     
     it "should never show a prefix for a class method" do
       obj = MethodObject.new(nil, :something, :class)
       obj.name.should == :"something"
-      obj.name(true).should == :"something"
+      obj.name(true).should == "something"
     end
   end
 end

data/spec/code_objects/module_object_spec.rb

@@ -1,131 +1,133 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe YARD::CodeObjects::ModuleObject, "#meths" do
-  before do 
-    Registry.clear 
+describe YARD::CodeObjects::ModuleObject do
+  describe "#meths" do
+    before do 
+      Registry.clear 
     
-    # setup the object space:
-    # 
-    #   YARD:module
-    #   YARD#foo:method
-    #   YARD#foo2:method
-    #   YARD#xyz:method
-    #   YARD.bar:method
-    #   SomeMod#mixmethod
-    #   SomeMod#xyz:method
-    # 
-    @yard = ModuleObject.new(:root, :YARD)
-    MethodObject.new(@yard, :foo)
-    MethodObject.new(@yard, :xyz)
-    MethodObject.new(@yard, :foo2) do |o|
-      o.visibility = :protected
-    end
-    MethodObject.new(@yard, :bar, :class) do |o|
-      o.visibility = :private
-    end
-    @other = ModuleObject.new(:root, :SomeMod)
-    MethodObject.new(@other, :mixmethod)
-    MethodObject.new(@other, :xyz)
-    MethodObject.new(@other, :baz, :class)
-    @another = ModuleObject.new(:root, :AnotherMod)
-    MethodObject.new(@another, :fizz)
-    MethodObject.new(@another, :bar)
-    MethodObject.new(@another, :fazz, :class)
+      # setup the object space:
+      # 
+      #   YARD:module
+      #   YARD#foo:method
+      #   YARD#foo2:method
+      #   YARD#xyz:method
+      #   YARD.bar:method
+      #   SomeMod#mixmethod
+      #   SomeMod#xyz:method
+      # 
+      @yard = ModuleObject.new(:root, :YARD)
+      MethodObject.new(@yard, :foo)
+      MethodObject.new(@yard, :xyz)
+      MethodObject.new(@yard, :foo2) do |o|
+        o.visibility = :protected
+      end
+      MethodObject.new(@yard, :bar, :class) do |o|
+        o.visibility = :private
+      end
+      @other = ModuleObject.new(:root, :SomeMod)
+      MethodObject.new(@other, :mixmethod)
+      MethodObject.new(@other, :xyz)
+      MethodObject.new(@other, :baz, :class)
+      @another = ModuleObject.new(:root, :AnotherMod)
+      MethodObject.new(@another, :fizz)
+      MethodObject.new(@another, :bar)
+      MethodObject.new(@another, :fazz, :class)
     
-    @yard.instance_mixins << @other
-    @yard.class_mixins << @another
-  end
+      @yard.instance_mixins << @other
+      @yard.class_mixins << @another
+    end
   
-  it "should list 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"))
-  end
+    it "should list 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"))
+    end
   
-  it "should allow :visibility to be set" do
-    meths = @yard.meths(:visibility => :public)
-    meths.should_not 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"))
-  end
+    it "should allow :visibility to be set" do
+      meths = @yard.meths(:visibility => :public)
+      meths.should_not 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"))
+    end
   
-  it "should only display 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"))
-  end
+    it "should only display 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"))
+    end
   
-  it "should only display 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"))
-  end
+    it "should only display 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"))
+    end
   
-  it "should allow :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"))
-  end
+    it "should allow :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"))
+    end
   
-  it "should choose 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"))
+    it "should choose 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"))
     
-    meths = @other.meths
-    meths.should include(P("SomeMod#xyz"))
+      meths = @other.meths
+      meths.should include(P("SomeMod#xyz"))
 
-    meths = @another.meths
-    meths.should include(P("AnotherMod#bar"))
+      meths = @another.meths
+      meths.should include(P("AnotherMod#bar"))
+    end
   end
-end
 
-describe YARD::CodeObjects::ModuleObject, "#inheritance_tree" do
-  before do
-    Registry.clear
+  describe "#inheritance_tree" do
+    before do
+      Registry.clear
 
-    @mod1 = ModuleObject.new(:root, :Mod1)
-    @mod2 = ModuleObject.new(:root, :Mod2)
-    @mod3 = ModuleObject.new(:root, :Mod3)
-    @mod4 = ModuleObject.new(:root, :Mod4)
-    @mod5 = ModuleObject.new(:root, :Mod5)
+      @mod1 = ModuleObject.new(:root, :Mod1)
+      @mod2 = ModuleObject.new(:root, :Mod2)
+      @mod3 = ModuleObject.new(:root, :Mod3)
+      @mod4 = ModuleObject.new(:root, :Mod4)
+      @mod5 = ModuleObject.new(:root, :Mod5)
 
-    @mod1.instance_mixins << @mod2
-    @mod2.instance_mixins << @mod3
-    @mod1.instance_mixins << @mod4
+      @mod1.instance_mixins << @mod2
+      @mod2.instance_mixins << @mod3
+      @mod1.instance_mixins << @mod4
     
-    @proxy = P(:SomeProxyClass)
-    @mod5.instance_mixins << @proxy
-  end
+      @proxy = P(:SomeProxyClass)
+      @mod5.instance_mixins << @proxy
+    end
 
-  it "should show only itself for an inheritance tree without included modules" do
-    @mod1.inheritance_tree.should == [@mod1]
-  end
+    it "should show only itself for an inheritance tree without included modules" do
+      @mod1.inheritance_tree.should == [@mod1]
+    end
 
-  it "should show proper inheritance three when modules are included" do
-    @mod1.inheritance_tree(true).should == [@mod1, @mod2, @mod3, @mod4]
-  end
+    it "should show proper inheritance three when modules are included" do
+      @mod1.inheritance_tree(true).should == [@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 "should not list inheritance tree of proxy objects in inheritance tree" do
+      @proxy.should_not_receive(:inheritance_tree)
+      @mod5.instance_mixins.should == [@proxy]
+    end  
   end
-end
+end

data/spec/code_objects/proxy_spec.rb

@@ -88,4 +88,13 @@ describe YARD::CodeObjects::Proxy do
     P("MYPROXY").should_not == Registry.root
     P("X::A").should_not == Registry.root
   end
+  
+  it "should reset 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
+  end
 end

data/spec/core_ext/array_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Array do
+  describe '#place' do
+    it "should create an Insertion object" do
+      [].place('x').should be_kind_of(Insertion)
+    end
+  end
+end
+
+describe Insertion do
+  describe '#before' do
+    it "should place an object before another" do
+      [1, 2].place(3).before(2).should == [1, 3, 2]
+      [1, 2].place(3).before(1).should == [3, 1, 2]
+      [1, [4], 2].place(3).before(2).should == [1, [4], 3, 2]
+    end
+  end
+  
+  describe '#after' do
+    it "should place an object after another" do
+      [1, 2].place(3).after(2).should == [1, 2, 3]
+    end
+
+    it "should place an object after another and its subsections" do
+      [1, [2]].place(3).after(1).should == [1, [2], 3]
+    end
+
+    it "should not not ignore subsections if ignore_subections=false" do
+      [1, [2]].place(3).after(1, false).should == [1, 3, [2]]
+    end
+  end
+end

data/spec/core_ext/file_spec.rb

@@ -1,20 +1,48 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe File, ".relative_path" do
-  it "should return the relative path between two files" do
-    File.relative_path('a/b/c/d.html', 'a/b/d/q.html').should == '../d/q.html'
-  end
+describe File do
+  describe ".relative_path" do
+    it "should return the relative path between two files" do
+      File.relative_path('a/b/c/d.html', 'a/b/d/q.html').should == '../d/q.html'
+    end
   
-  it "should return the relative path between two directories" do
-    File.relative_path('a/b/c/d/', 'a/b/d/').should == '../d'
-  end
+    it "should return the relative path between two directories" do
+      File.relative_path('a/b/c/d/', 'a/b/d/').should == '../d'
+    end
+  
+    it "should return only the to file if from file is in the same directory as the to file" do
+      File.relative_path('a/b/c/d', 'a/b/c/e').should == 'e'
+    end
   
-  it "should return only the to file if from file is in the same directory as the to file" do
-    File.relative_path('a/b/c/d', 'a/b/c/e').should == 'e'
+    it "should handle non-normalized paths" do
+      File.relative_path('Hello/./I/Am/Fred', 'Hello/Fred').should == '../../Fred'
+      File.relative_path('A//B/C', 'Q/X').should == '../../Q/X'
+    end
   end
   
-  it "should handle non-normalized paths" do
-    File.relative_path('Hello/./I/Am/Fred', 'Hello/Fred').should == '../../Fred'
-    File.relative_path('A//B/C', 'Q/X').should == '../../Q/X'
+  describe '.cleanpath' do
+    it "should clean double brackets" do
+      File.cleanpath('A//B/C').should == "A/B/C"
+    end
+    
+    it "should clean a path with ." do
+      File.cleanpath('Hello/./I/.Am/Fred').should == "Hello/I/.Am/Fred"
+    end
+
+    it "should clean a path with .." do
+      File.cleanpath('Hello/../World').should == "World"
+    end
+
+    it "should clean a path with multiple .." do
+      File.cleanpath('A/B/C/../../D').should == "A/D"
+    end
+
+    it "should clean a path ending in .." do
+      File.cleanpath('A/B/C/D/..').should == "A/B/C"
+    end
+    
+    it "should not pass the initial directory" do
+      File.cleanpath('C/../../D').should == "../D"
+    end
   end
 end

data/spec/core_ext/module_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Module do
+  describe '#class_name' do
+    it "should return just the name of the class/module" do
+      YARD::CodeObjects::Base.class_name.should == "Base"
+    end
+  end
+  
+  describe '#namespace' do
+    it "should return everything before the class name" do
+      YARD::CodeObjects::Base.namespace.should == "YARD::CodeObjects"
+    end
+  end
+end

data/spec/core_ext/string_spec.rb

@@ -3,14 +3,22 @@ require File.dirname(__FILE__) + '/../spec_helper'
 #described_in_docs String, '#camelcase'
 #described_in_docs String, '#underscore'
 
-describe String, '#camelcase' do
+describe String, '#underscore' do
   it 'should turn HelloWorld into hello_world' do
     "HelloWorld".underscore.should == "hello_world"
   end
+  
+  it "should turn Hello::World into hello/world" do
+    "Hello::World".underscore.should == "hello/world"
+  end
 end
 
-describe String, '#underscore' do
+describe String, '#camelcase' do
   it 'should turn hello_world into HelloWorld' do
     "hello_world".camelcase.should == "HelloWorld"
   end
+
+  it "should turn hello/world into Hello::World" do
+    "Hello::World".underscore.should == "hello/world"
+  end
 end

data/spec/docstring_spec.rb

@@ -3,166 +3,188 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe YARD::Docstring do
   before { YARD::Registry.clear }
   
-  it "should parse comments into tags" do
-    doc = Docstring.new(<<-eof)
-      @param name Hello world
-        how are you?
-      @param name2 
-        this is a new line
-      @param name3 and this
-        is a new paragraph:
+  describe '#initialize' do
+    it "should parse comments into tags" do
+      doc = Docstring.new(<<-eof)
+        @param name Hello world
+          how are you?
+        @param name2 
+          this is a new line
+        @param name3 and this
+          is a new paragraph:
 
-        right here.
-    eof
-    doc.tags("param").each do |tag|
-      if tag.name == "name"
-        tag.text.should == "Hello world how are you?"
-      elsif tag.name == "name2"
-        tag.text.should == "this is a new line"
-      elsif tag.name == "name3"
-        tag.text.should == "and this is a new paragraph:\n\nright here."
+          right here.
+      eof
+      doc.tags("param").each do |tag|
+        if tag.name == "name"
+          tag.text.should == "Hello world how are you?"
+        elsif tag.name == "name2"
+          tag.text.should == "this is a new line"
+        elsif tag.name == "name3"
+          tag.text.should == "and this is a new paragraph:\n\nright here."
+        end
       end
     end
-  end
   
-  it "should handle docstrings with empty newlines" do
-    Docstring.new("\n\n").should == ""
+    it "should handle docstrings with empty newlines" do
+      Docstring.new("\n\n").should == ""
+    end
+
+    it "should only parse tags with charset [A-Za-z_]" do
+      doc = Docstring.new
+      valid = %w( @testing @valid @is_a @is_A @__ )
+      invalid = %w( @ @return@ @param, @x.y @x-y )
+
+      log.enter_level(Logger::FATAL) do
+        {valid => 1, invalid => 0}.each do |tags, size|
+          tags.each do |tag|
+            class << doc
+              def create_tag(tag_name, *args)
+                add_tag Tags::Tag.new(tag_name, *args)
+              end
+            end
+            doc.all = tag
+            doc.tags(tag[1..-1]).size.should == size
+          end
+        end
+      end
+    end
   end
   
-  it "should handle empty docstrings with #summary" do
-    o1 = Docstring.new
-    o1.summary.should == ""
-  end
+  describe '#summary' do
+    it "should handle empty docstrings" do
+      o1 = Docstring.new
+      o1.summary.should == ""
+    end
   
-  it "should handle multiple calls to #summary" do
-    o1 = Docstring.new("Hello. world")
-    5.times { o1.summary.should == "Hello." }
-  end
+    it "should handle multiple calls" do
+      o1 = Docstring.new("Hello. world")
+      5.times { o1.summary.should == "Hello." }
+    end
 
-  it "should return the first sentence with #summary" do
-    o = Docstring.new("DOCSTRING. Another sentence")
-    o.summary.should == "DOCSTRING."
-  end
+    it "should return the first sentence" do
+      o = Docstring.new("DOCSTRING. Another sentence")
+      o.summary.should == "DOCSTRING."
+    end
 
-  it "should return the first paragraph with #summary" do
-    o = Docstring.new("DOCSTRING, and other stuff\n\nAnother sentence.")
-    o.summary.should == "DOCSTRING, and other stuff."
-  end
+    it "should return the first paragraph" do
+      o = Docstring.new("DOCSTRING, and other stuff\n\nAnother sentence.")
+      o.summary.should == "DOCSTRING, and other stuff."
+    end
 
-  it "should return proper summary when docstring is changed" do
-    o = Docstring.new "DOCSTRING, and other stuff\n\nAnother sentence."
-    o.summary.should == "DOCSTRING, and other stuff."
-    o = Docstring.new "DOCSTRING."
-    o.summary.should == "DOCSTRING."
-  end
+    it "should return proper summary when docstring is changed" do
+      o = Docstring.new "DOCSTRING, and other stuff\n\nAnother sentence."
+      o.summary.should == "DOCSTRING, and other stuff."
+      o = Docstring.new "DOCSTRING."
+      o.summary.should == "DOCSTRING."
+    end
 
-  it "should not double the ending period in docstring.summary" do
-    o = Docstring.new("Returns a list of tags specified by +name+ or all tags if +name+ is not specified.\n\nTest")
-    o.summary.should == "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
+    it "should not double the ending period" do
+      o = Docstring.new("Returns a list of tags specified by +name+ or all tags if +name+ is not specified.\n\nTest")
+      o.summary.should == "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
   
-    doc = Docstring.new(<<-eof)
+      doc = Docstring.new(<<-eof)
       
-      Returns a list of tags specified by +name+ or all tags if +name+ is not specified.
+        Returns a list of tags specified by +name+ or all tags if +name+ is not specified.
       
-      @param name the tag name to return data for, or nil for all tags
-      @return [Array<Tags::Tag>] the list of tags by the specified tag name
-    eof
-    doc.summary.should == "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
+        @param name the tag name to return data for, or nil for all tags
+        @return [Array<Tags::Tag>] the list of tags by the specified tag name
+      eof
+      doc.summary.should == "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
+    end
+    
+    it "should handle references embedded in summary" do
+      Docstring.new("Aliasing {Test.test}. Done.").summary.should == "Aliasing {Test.test}."
+    end
+    
+    it "should only end first sentence when outside parentheses" do
+      Docstring.new("Hello (the best.) world. Foo bar.").summary.should == "Hello (the best.) world."
+      Docstring.new("A[b.]c.").summary.should == "A[b.]c."
+    end
+    
+    it "should only see '.' as period if whitespace (or eof) follows" do
+      Docstring.new("hello 1.5 times.").summary.should == "hello 1.5 times."
+      Docstring.new("hello... me").summary.should == "hello..."
+      Docstring.new("hello.").summary.should == "hello."
+    end
   end
 
-  it "should only parse tags with charset [A-Za-z_]" do
-    doc = Docstring.new
-    valid = %w( @testing @valid @is_a @is_A @__ )
-    invalid = %w( @ @return@ @param, @x.y @x-y )
-
-    log.enter_level(Logger::FATAL) do
-      {valid => 1, invalid => 0}.each do |tags, size|
-        tags.each do |tag|
-          class << doc
-            def create_tag(tag_name, *args)
-              add_tag Tags::Tag.new(tag_name, *args)
-            end
-          end
-          doc.all = tag
-          doc.tags(tag[1..-1]).size.should == size
-        end
-      end
+  describe '#ref_tags' do
+    it "should parse reference tag into ref_tags" do
+      doc = Docstring.new("@return (see Foo#bar)")
+      doc.ref_tags.size.should == 1
+      doc.ref_tags.first.owner.should == P("Foo#bar")
+      doc.ref_tags.first.tag_name.should == "return"
+      doc.ref_tags.first.name.should be_nil
     end
-  end
-  
-  it "should parse reference tag into ref_tags" do
-    doc = Docstring.new("@return (see Foo#bar)")
-    doc.ref_tags.size.should == 1
-    doc.ref_tags.first.owner.should == P("Foo#bar")
-    doc.ref_tags.first.tag_name.should == "return"
-    doc.ref_tags.first.name.should be_nil
-  end
 
-  it "should parse named reference tag into ref_tags" do
-    doc = Docstring.new("@param blah \n   (see Foo#bar )")
-    doc.ref_tags.size.should == 1
-    doc.ref_tags.first.owner.should == P("Foo#bar")
-    doc.ref_tags.first.tag_name.should == "param"
-    doc.ref_tags.first.name.should == "blah"
-  end
+    it "should parse named reference tag into ref_tags" do
+      doc = Docstring.new("@param blah \n   (see Foo#bar )")
+      doc.ref_tags.size.should == 1
+      doc.ref_tags.first.owner.should == P("Foo#bar")
+      doc.ref_tags.first.tag_name.should == "param"
+      doc.ref_tags.first.name.should == "blah"
+    end
   
-  it "should fail to parse named reference tag into ref_tags" do
-    doc = Docstring.new("@param blah THIS_BREAKS_REFTAG (see Foo#bar)")
-    doc.ref_tags.size.should == 0
-  end
+    it "should fail to parse named reference tag into ref_tags" do
+      doc = Docstring.new("@param blah THIS_BREAKS_REFTAG (see Foo#bar)")
+      doc.ref_tags.size.should == 0
+    end
   
-  it "should return all valid reference tags along with #tags" do
-    o = CodeObjects::MethodObject.new(:root, 'Foo#bar')
-    o.docstring.add_tag Tags::Tag.new('return', 'testing')
-    doc = Docstring.new("@return (see Foo#bar)")
-    tags = doc.tags
-    tags.size.should == 1
-    tags.first.text.should == 'testing'
-    tags.first.should be_kind_of(Tags::RefTag)
-    tags.first.owner.should == o
-  end
+    it "should return all valid reference tags along with #tags" do
+      o = CodeObjects::MethodObject.new(:root, 'Foo#bar')
+      o.docstring.add_tag Tags::Tag.new('return', 'testing')
+      doc = Docstring.new("@return (see Foo#bar)")
+      tags = doc.tags
+      tags.size.should == 1
+      tags.first.text.should == 'testing'
+      tags.first.should be_kind_of(Tags::RefTag)
+      tags.first.owner.should == o
+    end
   
-  it "should return all valid named reference tags along with #tags(name)" do
-    o = CodeObjects::MethodObject.new(:root, 'Foo#bar')
-    o.docstring.add_tag Tags::Tag.new('param', 'testing', nil, '*args')
-    o.docstring.add_tag Tags::Tag.new('param', 'NOTtesting', nil, 'notargs')
-    doc = Docstring.new("@param *args (see Foo#bar)")
-    tags = doc.tags('param')
-    tags.size.should == 1
-    tags.first.text.should == 'testing'
-    tags.first.should be_kind_of(Tags::RefTag)
-    tags.first.owner.should == o
-  end
-
-  it "should ignore invalid reference tags" do
-    doc = Docstring.new("@param *args (see INVALID::TAG#tag)")
-    tags = doc.tags('param')
-    tags.size.should == 0
-  end
+    it "should return all valid named reference tags along with #tags(name)" do
+      o = CodeObjects::MethodObject.new(:root, 'Foo#bar')
+      o.docstring.add_tag Tags::Tag.new('param', 'testing', nil, '*args')
+      o.docstring.add_tag Tags::Tag.new('param', 'NOTtesting', nil, 'notargs')
+      doc = Docstring.new("@param *args (see Foo#bar)")
+      tags = doc.tags('param')
+      tags.size.should == 1
+      tags.first.text.should == 'testing'
+      tags.first.should be_kind_of(Tags::RefTag)
+      tags.first.owner.should == o
+    end
 
-  it "should be blank and empty if it has no content and no tags" do
-    Docstring.new.should be_blank
-    Docstring.new.should be_empty
+    it "should ignore invalid reference tags" do
+      doc = Docstring.new("@param *args (see INVALID::TAG#tag)")
+      tags = doc.tags('param')
+      tags.size.should == 0
+    end
   end
+  
+  describe '#empty?/#blank?' do
+    it "should be blank and empty if it has no content and no tags" do
+      Docstring.new.should be_blank
+      Docstring.new.should be_empty
+    end
 
-  it "shouldn't be empty or blank if it has content" do
-    d = Docstring.new("foo bar")
-    d.should_not be_empty
-    d.should_not be_blank
-  end
+    it "shouldn't be empty or blank if it has content" do
+      d = Docstring.new("foo bar")
+      d.should_not be_empty
+      d.should_not be_blank
+    end
 
-  it "should be empty but not blank if it has tags" do
-    d = Docstring.new("@param foo")
-    d.should be_empty
-    d.should_not be_blank
-  end
+    it "should be empty but not blank if it has tags" do
+      d = Docstring.new("@param foo")
+      d.should be_empty
+      d.should_not be_blank
+    end
 
-  it "should be empty but not blank if it has ref tags" do
-    o = CodeObjects::MethodObject.new(:root, 'Foo#bar')
-    o.docstring.add_tag Tags::Tag.new('return', 'testing')
-    d = Docstring.new("@return (see Foo#bar)")
-    d.should be_empty
-    d.should_not be_blank
+    it "should be empty but not blank if it has ref tags" do
+      o = CodeObjects::MethodObject.new(:root, 'Foo#bar')
+      o.docstring.add_tag Tags::Tag.new('return', 'testing')
+      d = Docstring.new("@return (see Foo#bar)")
+      d.should be_empty
+      d.should_not be_blank
+    end
   end
-  
 end