yard 0.9.18 → 0.9.19

data/spec/docstring_spec.rb

@@ -1,373 +1,373 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Docstring do
-  before { YARD::Registry.clear }
-
-  describe "#initialize" do
-    it "handles docstrings with empty newlines" do
-      expect(Docstring.new("\n\n")).to eq ""
-    end
-  end
-
-  describe "#+" do
-    it "adds another Docstring" do
-      d = Docstring.new("FOO") + Docstring.new("BAR")
-      expect(d).to eq "FOO\nBAR"
-    end
-
-    it "copies over tags" do
-      d1 = Docstring.new("FOO\n@api private\n")
-      d2 = Docstring.new("BAR\n@param foo descr")
-      d = (d1 + d2)
-      expect(d).to have_tag(:api)
-      expect(d).to have_tag(:param)
-    end
-
-    it "adds a String" do
-      d = Docstring.new("FOO") + "BAR"
-      expect(d).to eq "FOOBAR"
-    end
-  end
-
-  describe "#line" do
-    it "returns nil if #line_range is not set" do
-      expect(Docstring.new('foo').line).to be nil
-    end
-
-    it "returns line_range.first if #line_range is set" do
-      doc = Docstring.new('foo')
-      doc.line_range = (1..10)
-      expect(doc.line).to eq doc.line_range.first
-    end
-  end
-
-  describe "#summary" do
-    it "handles empty docstrings" do
-      o1 = Docstring.new
-      expect(o1.summary).to eq ""
-    end
-
-    it "handles multiple calls" do
-      o1 = Docstring.new("Hello. world")
-      5.times { expect(o1.summary).to eq "Hello." }
-    end
-
-    it "strips newlines in first paragraph before summarizing" do
-      doc = Docstring.new("Foo\n<code>==</code> bar.")
-      expect(doc.summary).to eq 'Foo <code>==</code> bar.'
-    end
-
-    it "returns the first sentence" do
-      o = Docstring.new("DOCSTRING. Another sentence")
-      expect(o.summary).to eq "DOCSTRING."
-    end
-
-    it "returns the first paragraph" do
-      o = Docstring.new("DOCSTRING, and other stuff\n\nAnother sentence.")
-      expect(o.summary).to eq "DOCSTRING, and other stuff."
-    end
-
-    it "returns proper summary when docstring is changed" do
-      o = Docstring.new "DOCSTRING, and other stuff\n\nAnother sentence."
-      expect(o.summary).to eq "DOCSTRING, and other stuff."
-      o = Docstring.new "DOCSTRING."
-      expect(o.summary).to eq "DOCSTRING."
-    end
-
-    it "does 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")
-      expect(o.summary).to eq "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
-
-      doc = Docstring.new(<<-eof)
-
-        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
-      expect(doc.summary).to eq "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
-    end
-
-    it "does not attach period if entire summary is include" do
-      YARD.parse_string "# docstring\ndef foo; end"
-      expect(Docstring.new("{include:#foo}").summary).to eq '{include:#foo}'
-      Registry.clear
-    end
-
-    it "handles references embedded in summary" do
-      expect(Docstring.new("Aliasing {Test.test}. Done.").summary).to eq "Aliasing {Test.test}."
-    end
-
-    it "only ends first sentence when outside parentheses" do
-      expect(Docstring.new("Hello (the best.) world. Foo bar.").summary).to eq "Hello (the best.) world."
-      expect(Docstring.new("A[b.]c.").summary).to eq "A[b.]c."
-    end
-
-    it "only sees '.' as period if whitespace (or eof) follows" do
-      expect(Docstring.new("hello 1.5 times.").summary).to eq "hello 1.5 times."
-      expect(Docstring.new("hello... me").summary).to eq "hello..."
-      expect(Docstring.new("hello.").summary).to eq "hello."
-    end
-
-    it "returns summary if there is a newline and parentheses count doesn't match" do
-      expect(Docstring.new("Happy method call :-)\n\nCall any time.").summary).to eq "Happy method call :-)."
-      expect(Docstring.new("Sad method call :-(\n\nCall any time.").summary).to eq "Sad method call :-(."
-      expect(Docstring.new("Hello (World. Forget to close.\n\nNew text").summary).to eq "Hello (World. Forget to close."
-      expect(Docstring.new("Hello (World. Forget to close\n\nNew text").summary).to eq "Hello (World. Forget to close."
-    end
-  end
-
-  describe "#ref_tags" do
-    it "parses reference tag into ref_tags" do
-      doc = Docstring.new("@return (see Foo#bar)")
-      expect(doc.ref_tags.size).to eq 1
-      expect(doc.ref_tags.first.owner).to eq P("Foo#bar")
-      expect(doc.ref_tags.first.tag_name).to eq "return"
-      expect(doc.ref_tags.first.name).to be nil
-    end
-
-    it "parses named reference tag into ref_tags" do
-      doc = Docstring.new("@param blah \n   (see Foo#bar )")
-      expect(doc.ref_tags.size).to eq 1
-      expect(doc.ref_tags.first.owner).to eq P("Foo#bar")
-      expect(doc.ref_tags.first.tag_name).to eq "param"
-      expect(doc.ref_tags.first.name).to eq "blah"
-    end
-
-    it "fails to parse named reference tag into ref_tags" do
-      doc = Docstring.new("@param blah THIS_BREAKS_REFTAG (see Foo#bar)")
-      expect(doc.ref_tags.size).to eq 0
-    end
-
-    it "returns 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
-      expect(tags.size).to eq 1
-      expect(tags.first.text).to eq 'testing'
-      expect(tags.first).to be_kind_of(Tags::RefTag)
-      expect(tags.first.owner).to eq o
-    end
-
-    it "returns 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')
-      expect(tags.size).to eq 1
-      expect(tags.first.text).to eq 'testing'
-      expect(tags.first).to be_kind_of(Tags::RefTag)
-      expect(tags.first.owner).to eq o
-    end
-
-    it "ignores invalid reference tags" do
-      doc = Docstring.new("@param *args (see INVALID::TAG#tag)")
-      tags = doc.tags('param')
-      expect(tags.size).to eq 0
-    end
-
-    it "resolves references to methods in the same class with #methname" do
-      klass = CodeObjects::ClassObject.new(:root, "Foo")
-      o = CodeObjects::MethodObject.new(klass, "bar")
-      ref = CodeObjects::MethodObject.new(klass, "baz")
-      o.docstring.add_tag Tags::Tag.new('param', 'testing', nil, 'arg1')
-      ref.docstring = "@param (see #bar)"
-
-      tags = ref.docstring.tags("param")
-      expect(tags.size).to eq 1
-      expect(tags.first.text).to eq "testing"
-      expect(tags.first).to be_kind_of(Tags::RefTag)
-      expect(tags.first.owner).to eq o
-    end
-
-    it "returns an empty list (and warning) if circular reftags are found" do
-      YARD.parse_string <<-eof
-        class Foo
-          # @param (see #b)
-          def a; end
-          # @param (see #a)
-          def b; end
-        end
-      eof
-
-      expect(log.io.string).to match(/error.*circular reference tag in `Foo#b'/)
-      expect(Registry.at('Foo#a').tags).to be_empty
-      expect(Registry.at('Foo#b').tags).to be_empty
-    end
-
-    it "returns an empty list (and warning) if self-circular reftags are found" do
-      YARD.parse_string <<-eof
-        class Foo
-          # @param (see #bar)
-          def bar; end
-        end
-      eof
-
-      expect(log.io.string).to match(/error.*circular reference tag in `Foo#bar'/)
-      expect(Registry.at('Foo#bar').tags).to be_empty
-    end
-  end
-
-  describe "#empty?/#blank?" do
-    before(:all) do
-      Tags::Library.define_tag "Invisible", :invisible_tag
-    end
-
-    it "is blank and empty if it has no content and no tags" do
-      expect(Docstring.new).to be_blank
-      expect(Docstring.new).to be_empty
-    end
-
-    it "isn't empty or blank if it has content" do
-      d = Docstring.new("foo bar")
-      expect(d).not_to be_empty
-      expect(d).not_to be_blank
-    end
-
-    it "is empty but not blank if it has tags" do
-      d = Docstring.new("@param foo")
-      expect(d).to be_empty
-      expect(d).not_to be_blank
-    end
-
-    it "is 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)")
-      expect(d).to be_empty
-      expect(d).not_to be_blank
-    end
-
-    it "is blank if it has no visible tags" do
-      d = Docstring.new("@invisible_tag value")
-      expect(d).to be_blank
-    end
-
-    it "is not blank if it has invisible tags and only_visible_tags = false" do
-      d = Docstring.new("@invisible_tag value")
-      d.add_tag Tags::Tag.new('invisible_tag', nil, nil)
-      expect(d.blank?(false)).to be false
-    end
-  end
-
-  describe "#delete_tags" do
-    it "deletes tags by a given tag name" do
-      doc = Docstring.new("@param name x\n@param name2 y\n@return foo")
-      doc.delete_tags(:param)
-      expect(doc.tags.size).to eq 1
-    end
-  end
-
-  describe "#delete_tag_if" do
-    it "deletes tags for a given block" do
-      doc = Docstring.new("@param name x\n@param name2 y\n@return foo")
-      doc.delete_tag_if {|t| t.name == 'name2' }
-      expect(doc.tags.size).to eq 2
-    end
-  end
-
-  describe "#to_raw" do
-    it "returns a clean representation of tags" do
-      doc = Docstring.new("Hello world\n@return [String, X] foobar\n@param name<Array> the name\nBYE!")
-      expect(doc.to_raw).to eq "Hello world\nBYE!\n@param [Array] name\n  the name\n@return [String, X] foobar"
-    end
-
-    it "handles tags with newlines and indentation" do
-      doc = Docstring.new("@example TITLE\n  the \n  example\n  @foo\n@param [X] name\n  the name")
-      expect(doc.to_raw).to eq "@example TITLE\n  the \n  example\n  @foo\n@param [X] name\n  the name"
-    end
-
-    it "handles deleted tags" do
-      doc = Docstring.new("@example TITLE\n  the \n  example\n  @foo\n@param [X] name\n  the name")
-      doc.delete_tags(:param)
-      expect(doc.to_raw).to eq "@example TITLE\n  the \n  example\n  @foo"
-    end
-
-    it "handles added tags" do
-      doc = Docstring.new("@example TITLE\n  the \n  example\n  @foo")
-      doc.add_tag(Tags::Tag.new('foo', 'foo'))
-      expect(doc.to_raw).to eq "@example TITLE\n  the \n  example\n  @foo\n@foo foo"
-    end
-
-    it "is equal to .all if not modified" do
-      doc = Docstring.new("123\n@param")
-      expect(doc.to_raw).to eq doc.all
-    end
-
-    it "is stable sorting tags" do
-      expected = Docstring.new("123\n@param x\n@param y\n@version A")
-      doc = Docstring.new("123")
-      doc.add_tag(Tags::Tag.new('version', 'A'))
-      doc.add_tag(Tags::Tag.new('param', 'x'))
-      doc.add_tag(Tags::Tag.new('param', 'y'))
-      expect(doc.to_raw).to eq expected.all
-    end
-
-    # @bug gh-563
-    it "handles full @option tags" do
-      doc = Docstring.new("@option foo [String] bar (nil) baz")
-      expect(doc.to_raw).to eq "@option foo [String] bar (nil) baz"
-    end
-
-    # @bug gh-563
-    it "handles simple @option tags" do
-      doc = Docstring.new("@option foo :key bar")
-      expect(doc.to_raw).to eq "@option foo :key bar"
-    end
-  end
-
-  describe "#dup" do
-    it "duplicates docstring text" do
-      doc = Docstring.new("foo")
-      expect(doc.dup).to eq doc
-      expect(doc.dup.all).to eq doc
-    end
-
-    it "duplicates tags to new list" do
-      doc = Docstring.new("@param x\n@return y")
-      doc2 = doc.dup
-      doc2.delete_tags(:param)
-      expect(doc.tags.size).to eq 2
-      expect(doc2.tags.size).to eq 1
-    end
-
-    it "preserves summary" do
-      doc = Docstring.new("foo. bar")
-      expect(doc.dup.summary).to eq doc.summary
-    end
-
-    it "preserves hash_flag" do
-      doc = Docstring.new
-      doc.hash_flag = 'foo'
-      expect(doc.dup.hash_flag).to eq doc.hash_flag
-    end
-
-    it "preserves line_range" do
-      doc = Docstring.new
-      doc.line_range = (1..2)
-      expect(doc.dup.line_range).to eq doc.line_range
-    end
-  end
-
-  describe "reference docstrings" do
-    it "allows for construction of docstring with ref object" do
-      YARD.parse_string <<-eof
-        class A
-          # Docstring
-          # @return [Boolean]
-          def a; end
-          # (see #a)
-          def b; end
-        end
-      eof
-
-      object = YARD::Registry.at('A#b')
-      expect(object.docstring).to eq 'Docstring'
-      expect(object.tags.map(&:tag_name)).to eq ['return']
-
-      YARD::Registry.clear
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Docstring do
+  before { YARD::Registry.clear }
+
+  describe "#initialize" do
+    it "handles docstrings with empty newlines" do
+      expect(Docstring.new("\n\n")).to eq ""
+    end
+  end
+
+  describe "#+" do
+    it "adds another Docstring" do
+      d = Docstring.new("FOO") + Docstring.new("BAR")
+      expect(d).to eq "FOO\nBAR"
+    end
+
+    it "copies over tags" do
+      d1 = Docstring.new("FOO\n@api private\n")
+      d2 = Docstring.new("BAR\n@param foo descr")
+      d = (d1 + d2)
+      expect(d).to have_tag(:api)
+      expect(d).to have_tag(:param)
+    end
+
+    it "adds a String" do
+      d = Docstring.new("FOO") + "BAR"
+      expect(d).to eq "FOOBAR"
+    end
+  end
+
+  describe "#line" do
+    it "returns nil if #line_range is not set" do
+      expect(Docstring.new('foo').line).to be nil
+    end
+
+    it "returns line_range.first if #line_range is set" do
+      doc = Docstring.new('foo')
+      doc.line_range = (1..10)
+      expect(doc.line).to eq doc.line_range.first
+    end
+  end
+
+  describe "#summary" do
+    it "handles empty docstrings" do
+      o1 = Docstring.new
+      expect(o1.summary).to eq ""
+    end
+
+    it "handles multiple calls" do
+      o1 = Docstring.new("Hello. world")
+      5.times { expect(o1.summary).to eq "Hello." }
+    end
+
+    it "strips newlines in first paragraph before summarizing" do
+      doc = Docstring.new("Foo\n<code>==</code> bar.")
+      expect(doc.summary).to eq 'Foo <code>==</code> bar.'
+    end
+
+    it "returns the first sentence" do
+      o = Docstring.new("DOCSTRING. Another sentence")
+      expect(o.summary).to eq "DOCSTRING."
+    end
+
+    it "returns the first paragraph" do
+      o = Docstring.new("DOCSTRING, and other stuff\n\nAnother sentence.")
+      expect(o.summary).to eq "DOCSTRING, and other stuff."
+    end
+
+    it "returns proper summary when docstring is changed" do
+      o = Docstring.new "DOCSTRING, and other stuff\n\nAnother sentence."
+      expect(o.summary).to eq "DOCSTRING, and other stuff."
+      o = Docstring.new "DOCSTRING."
+      expect(o.summary).to eq "DOCSTRING."
+    end
+
+    it "does 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")
+      expect(o.summary).to eq "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
+
+      doc = Docstring.new(<<-eof)
+
+        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
+      expect(doc.summary).to eq "Returns a list of tags specified by +name+ or all tags if +name+ is not specified."
+    end
+
+    it "does not attach period if entire summary is include" do
+      YARD.parse_string "# docstring\ndef foo; end"
+      expect(Docstring.new("{include:#foo}").summary).to eq '{include:#foo}'
+      Registry.clear
+    end
+
+    it "handles references embedded in summary" do
+      expect(Docstring.new("Aliasing {Test.test}. Done.").summary).to eq "Aliasing {Test.test}."
+    end
+
+    it "only ends first sentence when outside parentheses" do
+      expect(Docstring.new("Hello (the best.) world. Foo bar.").summary).to eq "Hello (the best.) world."
+      expect(Docstring.new("A[b.]c.").summary).to eq "A[b.]c."
+    end
+
+    it "only sees '.' as period if whitespace (or eof) follows" do
+      expect(Docstring.new("hello 1.5 times.").summary).to eq "hello 1.5 times."
+      expect(Docstring.new("hello... me").summary).to eq "hello..."
+      expect(Docstring.new("hello.").summary).to eq "hello."
+    end
+
+    it "returns summary if there is a newline and parentheses count doesn't match" do
+      expect(Docstring.new("Happy method call :-)\n\nCall any time.").summary).to eq "Happy method call :-)."
+      expect(Docstring.new("Sad method call :-(\n\nCall any time.").summary).to eq "Sad method call :-(."
+      expect(Docstring.new("Hello (World. Forget to close.\n\nNew text").summary).to eq "Hello (World. Forget to close."
+      expect(Docstring.new("Hello (World. Forget to close\n\nNew text").summary).to eq "Hello (World. Forget to close."
+    end
+  end
+
+  describe "#ref_tags" do
+    it "parses reference tag into ref_tags" do
+      doc = Docstring.new("@return (see Foo#bar)")
+      expect(doc.ref_tags.size).to eq 1
+      expect(doc.ref_tags.first.owner).to eq P("Foo#bar")
+      expect(doc.ref_tags.first.tag_name).to eq "return"
+      expect(doc.ref_tags.first.name).to be nil
+    end
+
+    it "parses named reference tag into ref_tags" do
+      doc = Docstring.new("@param blah \n   (see Foo#bar )")
+      expect(doc.ref_tags.size).to eq 1
+      expect(doc.ref_tags.first.owner).to eq P("Foo#bar")
+      expect(doc.ref_tags.first.tag_name).to eq "param"
+      expect(doc.ref_tags.first.name).to eq "blah"
+    end
+
+    it "fails to parse named reference tag into ref_tags" do
+      doc = Docstring.new("@param blah THIS_BREAKS_REFTAG (see Foo#bar)")
+      expect(doc.ref_tags.size).to eq 0
+    end
+
+    it "returns 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
+      expect(tags.size).to eq 1
+      expect(tags.first.text).to eq 'testing'
+      expect(tags.first).to be_kind_of(Tags::RefTag)
+      expect(tags.first.owner).to eq o
+    end
+
+    it "returns 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')
+      expect(tags.size).to eq 1
+      expect(tags.first.text).to eq 'testing'
+      expect(tags.first).to be_kind_of(Tags::RefTag)
+      expect(tags.first.owner).to eq o
+    end
+
+    it "ignores invalid reference tags" do
+      doc = Docstring.new("@param *args (see INVALID::TAG#tag)")
+      tags = doc.tags('param')
+      expect(tags.size).to eq 0
+    end
+
+    it "resolves references to methods in the same class with #methname" do
+      klass = CodeObjects::ClassObject.new(:root, "Foo")
+      o = CodeObjects::MethodObject.new(klass, "bar")
+      ref = CodeObjects::MethodObject.new(klass, "baz")
+      o.docstring.add_tag Tags::Tag.new('param', 'testing', nil, 'arg1')
+      ref.docstring = "@param (see #bar)"
+
+      tags = ref.docstring.tags("param")
+      expect(tags.size).to eq 1
+      expect(tags.first.text).to eq "testing"
+      expect(tags.first).to be_kind_of(Tags::RefTag)
+      expect(tags.first.owner).to eq o
+    end
+
+    it "returns an empty list (and warning) if circular reftags are found" do
+      YARD.parse_string <<-eof
+        class Foo
+          # @param (see #b)
+          def a; end
+          # @param (see #a)
+          def b; end
+        end
+      eof
+
+      expect(log.io.string).to match(/error.*circular reference tag in `Foo#b'/)
+      expect(Registry.at('Foo#a').tags).to be_empty
+      expect(Registry.at('Foo#b').tags).to be_empty
+    end
+
+    it "returns an empty list (and warning) if self-circular reftags are found" do
+      YARD.parse_string <<-eof
+        class Foo
+          # @param (see #bar)
+          def bar; end
+        end
+      eof
+
+      expect(log.io.string).to match(/error.*circular reference tag in `Foo#bar'/)
+      expect(Registry.at('Foo#bar').tags).to be_empty
+    end
+  end
+
+  describe "#empty?/#blank?" do
+    before(:all) do
+      Tags::Library.define_tag "Invisible", :invisible_tag
+    end
+
+    it "is blank and empty if it has no content and no tags" do
+      expect(Docstring.new).to be_blank
+      expect(Docstring.new).to be_empty
+    end
+
+    it "isn't empty or blank if it has content" do
+      d = Docstring.new("foo bar")
+      expect(d).not_to be_empty
+      expect(d).not_to be_blank
+    end
+
+    it "is empty but not blank if it has tags" do
+      d = Docstring.new("@param foo")
+      expect(d).to be_empty
+      expect(d).not_to be_blank
+    end
+
+    it "is 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)")
+      expect(d).to be_empty
+      expect(d).not_to be_blank
+    end
+
+    it "is blank if it has no visible tags" do
+      d = Docstring.new("@invisible_tag value")
+      expect(d).to be_blank
+    end
+
+    it "is not blank if it has invisible tags and only_visible_tags = false" do
+      d = Docstring.new("@invisible_tag value")
+      d.add_tag Tags::Tag.new('invisible_tag', nil, nil)
+      expect(d.blank?(false)).to be false
+    end
+  end
+
+  describe "#delete_tags" do
+    it "deletes tags by a given tag name" do
+      doc = Docstring.new("@param name x\n@param name2 y\n@return foo")
+      doc.delete_tags(:param)
+      expect(doc.tags.size).to eq 1
+    end
+  end
+
+  describe "#delete_tag_if" do
+    it "deletes tags for a given block" do
+      doc = Docstring.new("@param name x\n@param name2 y\n@return foo")
+      doc.delete_tag_if {|t| t.name == 'name2' }
+      expect(doc.tags.size).to eq 2
+    end
+  end
+
+  describe "#to_raw" do
+    it "returns a clean representation of tags" do
+      doc = Docstring.new("Hello world\n@return [String, X] foobar\n@param name<Array> the name\nBYE!")
+      expect(doc.to_raw).to eq "Hello world\nBYE!\n@param [Array] name\n  the name\n@return [String, X] foobar"
+    end
+
+    it "handles tags with newlines and indentation" do
+      doc = Docstring.new("@example TITLE\n  the \n  example\n  @foo\n@param [X] name\n  the name")
+      expect(doc.to_raw).to eq "@example TITLE\n  the \n  example\n  @foo\n@param [X] name\n  the name"
+    end
+
+    it "handles deleted tags" do
+      doc = Docstring.new("@example TITLE\n  the \n  example\n  @foo\n@param [X] name\n  the name")
+      doc.delete_tags(:param)
+      expect(doc.to_raw).to eq "@example TITLE\n  the \n  example\n  @foo"
+    end
+
+    it "handles added tags" do
+      doc = Docstring.new("@example TITLE\n  the \n  example\n  @foo")
+      doc.add_tag(Tags::Tag.new('foo', 'foo'))
+      expect(doc.to_raw).to eq "@example TITLE\n  the \n  example\n  @foo\n@foo foo"
+    end
+
+    it "is equal to .all if not modified" do
+      doc = Docstring.new("123\n@param")
+      expect(doc.to_raw).to eq doc.all
+    end
+
+    it "is stable sorting tags" do
+      expected = Docstring.new("123\n@param x\n@param y\n@version A")
+      doc = Docstring.new("123")
+      doc.add_tag(Tags::Tag.new('version', 'A'))
+      doc.add_tag(Tags::Tag.new('param', 'x'))
+      doc.add_tag(Tags::Tag.new('param', 'y'))
+      expect(doc.to_raw).to eq expected.all
+    end
+
+    # @bug gh-563
+    it "handles full @option tags" do
+      doc = Docstring.new("@option foo [String] bar (nil) baz")
+      expect(doc.to_raw).to eq "@option foo [String] bar (nil) baz"
+    end
+
+    # @bug gh-563
+    it "handles simple @option tags" do
+      doc = Docstring.new("@option foo :key bar")
+      expect(doc.to_raw).to eq "@option foo :key bar"
+    end
+  end
+
+  describe "#dup" do
+    it "duplicates docstring text" do
+      doc = Docstring.new("foo")
+      expect(doc.dup).to eq doc
+      expect(doc.dup.all).to eq doc
+    end
+
+    it "duplicates tags to new list" do
+      doc = Docstring.new("@param x\n@return y")
+      doc2 = doc.dup
+      doc2.delete_tags(:param)
+      expect(doc.tags.size).to eq 2
+      expect(doc2.tags.size).to eq 1
+    end
+
+    it "preserves summary" do
+      doc = Docstring.new("foo. bar")
+      expect(doc.dup.summary).to eq doc.summary
+    end
+
+    it "preserves hash_flag" do
+      doc = Docstring.new
+      doc.hash_flag = 'foo'
+      expect(doc.dup.hash_flag).to eq doc.hash_flag
+    end
+
+    it "preserves line_range" do
+      doc = Docstring.new
+      doc.line_range = (1..2)
+      expect(doc.dup.line_range).to eq doc.line_range
+    end
+  end
+
+  describe "reference docstrings" do
+    it "allows for construction of docstring with ref object" do
+      YARD.parse_string <<-eof
+        class A
+          # Docstring
+          # @return [Boolean]
+          def a; end
+          # (see #a)
+          def b; end
+        end
+      eof
+
+      object = YARD::Registry.at('A#b')
+      expect(object.docstring).to eq 'Docstring'
+      expect(object.tags.map(&:tag_name)).to eq ['return']
+
+      YARD::Registry.clear
+    end
+  end
+end