yard 0.9.18 → 0.9.19

data/spec/tags/library_spec.rb

@@ -1,48 +1,48 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Tags::Library do
-  def tag(docstring)
-    Docstring.new(docstring).tags.first
-  end
-
-  describe "#see_tag" do
-    it "takes a URL" do
-      expect(tag("@see http://example.com").name).to eq "http://example.com"
-    end
-
-    it "takes an object path" do
-      expect(tag("@see String#reverse").name).to eq "String#reverse"
-    end
-
-    it "takes a description after the url/object" do
-      tag = tag("@see http://example.com An Example Site")
-      expect(tag.name).to eq "http://example.com"
-      expect(tag.text).to eq "An Example Site"
-    end
-  end
-
-  describe ".define_tag" do
-    it "allows defining tags with '.' in the name (x.y.z defines method x_y_z)" do
-      Tags::Library.define_tag("foo", 'x.y.z')
-      Tags::Library.define_tag("foo2", 'x.y.zz', Tags::OverloadTag)
-      expect(Tags::Library.instance.method(:x_y_z_tag)).not_to be nil
-      expect(Tags::Library.instance.method(:x_y_zz_tag)).not_to be nil
-      expect(tag('@x.y.z foo bar').text).to eq 'foo bar'
-      expect(tag('@x.y.zz foo(bar)').signature).to eq 'foo(bar)'
-    end
-  end
-
-  describe "#tag.explain_types" do
-    it "can explain tag types" do
-      expect(tag("@return [A, B<String>]").explain_types).to eq "an A; a B of (Strings)"
-    end
-
-    it "returns nil if no types present" do
-      expect(tag("@return").explain_types).to eq nil
-    end
-
-    it "returns nil if types are not parseable" do
-      expect(tag("@return [$]").explain_types).to eq nil
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Tags::Library do
+  def tag(docstring)
+    Docstring.new(docstring).tags.first
+  end
+
+  describe "#see_tag" do
+    it "takes a URL" do
+      expect(tag("@see http://example.com").name).to eq "http://example.com"
+    end
+
+    it "takes an object path" do
+      expect(tag("@see String#reverse").name).to eq "String#reverse"
+    end
+
+    it "takes a description after the url/object" do
+      tag = tag("@see http://example.com An Example Site")
+      expect(tag.name).to eq "http://example.com"
+      expect(tag.text).to eq "An Example Site"
+    end
+  end
+
+  describe ".define_tag" do
+    it "allows defining tags with '.' in the name (x.y.z defines method x_y_z)" do
+      Tags::Library.define_tag("foo", 'x.y.z')
+      Tags::Library.define_tag("foo2", 'x.y.zz', Tags::OverloadTag)
+      expect(Tags::Library.instance.method(:x_y_z_tag)).not_to be nil
+      expect(Tags::Library.instance.method(:x_y_zz_tag)).not_to be nil
+      expect(tag('@x.y.z foo bar').text).to eq 'foo bar'
+      expect(tag('@x.y.zz foo(bar)').signature).to eq 'foo(bar)'
+    end
+  end
+
+  describe "#tag.explain_types" do
+    it "can explain tag types" do
+      expect(tag("@return [A, B<String>]").explain_types).to eq "an A; a B of (Strings)"
+    end
+
+    it "returns nil if no types present" do
+      expect(tag("@return").explain_types).to eq nil
+    end
+
+    it "returns nil if types are not parseable" do
+      expect(tag("@return [$]").explain_types).to eq nil
+    end
+  end
+end

data/spec/tags/overload_tag_spec.rb

@@ -1,53 +1,53 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Tags::OverloadTag do
-  before do
-    @tag = Tags::OverloadTag.new(:overload, <<-'eof')
-      def bar(a, b = 1, &block)
-        Hello world
-        @param a [String]
-        @return [String]
-    eof
-  end
-
-  it "parses the first line as a method signature" do
-    expect(@tag.signature).to eq "def bar(a, b = 1, &block)"
-    expect(@tag.parameters).to eq [['a', nil], ['b', "1"], ['&block', nil]]
-  end
-
-  it "parses the rest of the text as a new Docstring" do
-    expect(@tag.docstring).to be_instance_of(Docstring)
-    expect(@tag.docstring).to eq "Hello world"
-  end
-
-  it "sets Docstring's object after #object= is called" do
-    m = double(:object)
-    @tag.object = m
-    expect(@tag.docstring.object).to eq m
-  end
-
-  it "responds to #tag, #tags and #has_tag?" do
-    @tag.object = double(:object)
-    expect(@tag.tags.size).to eq 2
-    expect(@tag.tag(:param).name).to eq "a"
-    expect(@tag.has_tag?(:return)).to be true
-  end
-
-  it "is not a CodeObjects::Base when not hooked up to an object" do
-    @tag.object = nil
-    expect(@tag.is_a?(CodeObjects::Base)).to be false
-  end
-
-  it "is a CodeObjects::Base when hooked up to an object" do
-    @tag.object = double(:object)
-    expect(@tag.object).to receive(:is_a?).at_least(3).times.with(CodeObjects::Base).and_return(true)
-    expect(@tag.is_a?(CodeObjects::Base)).to be true
-    expect(@tag.is_a?(CodeObjects::Base)).to be true
-    expect(CodeObjects::Base === @tag).to be true
-  end
-
-  it "does not parse 'def' out of method name" do
-    tag = Tags::OverloadTag.new(:overload, "default")
-    expect(tag.signature).to eq "default"
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Tags::OverloadTag do
+  before do
+    @tag = Tags::OverloadTag.new(:overload, <<-'eof')
+      def bar(a, b = 1, &block)
+        Hello world
+        @param a [String]
+        @return [String]
+    eof
+  end
+
+  it "parses the first line as a method signature" do
+    expect(@tag.signature).to eq "def bar(a, b = 1, &block)"
+    expect(@tag.parameters).to eq [['a', nil], ['b', "1"], ['&block', nil]]
+  end
+
+  it "parses the rest of the text as a new Docstring" do
+    expect(@tag.docstring).to be_instance_of(Docstring)
+    expect(@tag.docstring).to eq "Hello world"
+  end
+
+  it "sets Docstring's object after #object= is called" do
+    m = double(:object)
+    @tag.object = m
+    expect(@tag.docstring.object).to eq m
+  end
+
+  it "responds to #tag, #tags and #has_tag?" do
+    @tag.object = double(:object)
+    expect(@tag.tags.size).to eq 2
+    expect(@tag.tag(:param).name).to eq "a"
+    expect(@tag.has_tag?(:return)).to be true
+  end
+
+  it "is not a CodeObjects::Base when not hooked up to an object" do
+    @tag.object = nil
+    expect(@tag.is_a?(CodeObjects::Base)).to be false
+  end
+
+  it "is a CodeObjects::Base when hooked up to an object" do
+    @tag.object = double(:object)
+    expect(@tag.object).to receive(:is_a?).at_least(3).times.with(CodeObjects::Base).and_return(true)
+    expect(@tag.is_a?(CodeObjects::Base)).to be true
+    expect(@tag.is_a?(CodeObjects::Base)).to be true
+    expect(CodeObjects::Base === @tag).to be true
+  end
+
+  it "does not parse 'def' out of method name" do
+    tag = Tags::OverloadTag.new(:overload, "default")
+    expect(tag.signature).to eq "default"
+  end
+end

data/spec/tags/ref_tag_list_spec.rb

@@ -1,53 +1,53 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Tags::RefTagList do
-  before { YARD::Registry.clear }
-
-  it "accepts symbol or string as owner's path and convert it into a proxy" do
-    t = Tags::RefTagList.new('author', :String)
-    expect(t.owner).to eq P(:String)
-  end
-
-  it "accepts proxy object as owner" do
-    t = Tags::RefTagList.new('author', P(:String))
-    expect(t.owner).to eq P(:String)
-  end
-
-  it "returns tags from a proxy object" do
-    o = CodeObjects::ClassObject.new(:root, :String)
-    t = Tags::Tag.new(:author, 'foo')
-    o.docstring.add_tag(t)
-
-    ref = Tags::RefTagList.new('author', :String)
-    expect(ref.tags).to eq [t]
-    expect(ref.tags.first.text).to eq 'foo'
-  end
-
-  it "returns named tags from a proxy object" do
-    o = CodeObjects::ClassObject.new(:root, :String)
-    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
-    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
-    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
-    t1 = Tags::Tag.new(:return, 'blah')
-    o.docstring.add_tag(p1, t1, p2, p3)
-
-    ref = Tags::RefTagList.new('param', :String, 'foo')
-    expect(ref.tags).to eq [p1, p2]
-    expect(ref.tags.first.text).to eq 'bar1'
-  end
-
-  it "all tags should respond to #owner and be a RefTag" do
-    o = CodeObjects::ClassObject.new(:root, :String)
-    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
-    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
-    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
-    t1 = Tags::Tag.new(:return, 'blah')
-    o.docstring.add_tag(p1, t1, p2, p3)
-
-    ref = Tags::RefTagList.new('param', :String)
-    ref.tags.each do |t|
-      expect(t).to be_kind_of(Tags::RefTag)
-      expect(t.owner).to eq o
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Tags::RefTagList do
+  before { YARD::Registry.clear }
+
+  it "accepts symbol or string as owner's path and convert it into a proxy" do
+    t = Tags::RefTagList.new('author', :String)
+    expect(t.owner).to eq P(:String)
+  end
+
+  it "accepts proxy object as owner" do
+    t = Tags::RefTagList.new('author', P(:String))
+    expect(t.owner).to eq P(:String)
+  end
+
+  it "returns tags from a proxy object" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    t = Tags::Tag.new(:author, 'foo')
+    o.docstring.add_tag(t)
+
+    ref = Tags::RefTagList.new('author', :String)
+    expect(ref.tags).to eq [t]
+    expect(ref.tags.first.text).to eq 'foo'
+  end
+
+  it "returns named tags from a proxy object" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
+    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
+    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
+    t1 = Tags::Tag.new(:return, 'blah')
+    o.docstring.add_tag(p1, t1, p2, p3)
+
+    ref = Tags::RefTagList.new('param', :String, 'foo')
+    expect(ref.tags).to eq [p1, p2]
+    expect(ref.tags.first.text).to eq 'bar1'
+  end
+
+  it "all tags should respond to #owner and be a RefTag" do
+    o = CodeObjects::ClassObject.new(:root, :String)
+    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
+    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
+    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
+    t1 = Tags::Tag.new(:return, 'blah')
+    o.docstring.add_tag(p1, t1, p2, p3)
+
+    ref = Tags::RefTagList.new('param', :String)
+    ref.tags.each do |t|
+      expect(t).to be_kind_of(Tags::RefTag)
+      expect(t.owner).to eq o
+    end
+  end
+end

data/spec/tags/types_explainer_spec.rb

@@ -1,203 +1,203 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Tags::TypesExplainer do
-  Type = YARD::Tags::TypesExplainer::Type
-  CollectionType = YARD::Tags::TypesExplainer::CollectionType
-  FixedCollectionType = YARD::Tags::TypesExplainer::FixedCollectionType
-  HashCollectionType = YARD::Tags::TypesExplainer::HashCollectionType
-  Parser = YARD::Tags::TypesExplainer::Parser
-
-  def parse(types)
-    Parser.new(types).parse
-  end
-
-  def parse_fail(types)
-    expect(lambda { parse(types) }).to raise_error(SyntaxError)
-  end
-
-  describe Type, '#to_s' do
-    before { @t = Type.new(nil) }
-
-    it "works for a class/module reference" do
-      @t.name = "ClassModuleName"
-      expect(@t.to_s).to eq "a ClassModuleName"
-      expect(@t.to_s(false)).to eq "ClassModuleNames"
-
-      @t.name = "XYZ"
-      expect(@t.to_s).to eq "a XYZ"
-      expect(@t.to_s(false)).to eq "XYZ's"
-
-      @t.name = "Array"
-      expect(@t.to_s).to eq "an Array"
-      expect(@t.to_s(false)).to eq "Arrays"
-    end
-
-    it "works for a method (ducktype)" do
-      @t.name = "#mymethod"
-      expect(@t.to_s).to eq "an object that responds to #mymethod"
-      expect(@t.to_s(false)).to eq "objects that respond to #mymethod"
-    end
-
-    it "works for a constant value" do
-      ['false', 'true', 'nil', '4'].each do |name|
-        @t.name = name
-        expect(@t.to_s).to eq name
-        expect(@t.to_s(false)).to eq name
-      end
-    end
-  end
-
-  describe CollectionType, '#to_s' do
-    before { @t = CollectionType.new("Array", nil) }
-
-    it "can contain one item" do
-      @t.types = [Type.new("Object")]
-      expect(@t.to_s).to eq "an Array of (Objects)"
-    end
-
-    it "can contain more than one item" do
-      @t.types = [Type.new("Object"), Type.new("String"), Type.new("Symbol")]
-      expect(@t.to_s).to eq "an Array of (Objects, Strings or Symbols)"
-    end
-
-    it "can contain nested collections" do
-      @t.types = [CollectionType.new("List", [Type.new("Object")])]
-      expect(@t.to_s).to eq "an Array of (a List of (Objects))"
-    end
-  end
-
-  describe FixedCollectionType, '#to_s' do
-    before { @t = FixedCollectionType.new("Array", nil) }
-
-    it "can contain one item" do
-      @t.types = [Type.new("Object")]
-      expect(@t.to_s).to eq "an Array containing (an Object)"
-    end
-
-    it "can contain more than one item" do
-      @t.types = [Type.new("Object"), Type.new("String"), Type.new("Symbol")]
-      expect(@t.to_s).to eq "an Array containing (an Object followed by a String followed by a Symbol)"
-    end
-
-    it "can contain nested collections" do
-      @t.types = [FixedCollectionType.new("List", [Type.new("Object")])]
-      expect(@t.to_s).to eq "an Array containing (a List containing (an Object))"
-    end
-  end
-
-  describe FixedCollectionType, '#to_s' do
-    before { @t = HashCollectionType.new("Hash", nil, nil) }
-
-    it "can contain a single key type and value type" do
-      @t.key_types = [Type.new("Object")]
-      @t.value_types = [Type.new("Object")]
-      expect(@t.to_s).to eq "a Hash with keys made of (Objects) and values of (Objects)"
-    end
-
-    it "can contain multiple key types" do
-      @t.key_types = [Type.new("Key"), Type.new("String")]
-      @t.value_types = [Type.new("Object")]
-      expect(@t.to_s).to eq "a Hash with keys made of (Keys or Strings) and values of (Objects)"
-    end
-
-    it "can contain multiple value types" do
-      @t.key_types = [Type.new("String")]
-      @t.value_types = [Type.new("true"), Type.new("false")]
-      expect(@t.to_s).to eq "a Hash with keys made of (Strings) and values of (true or false)"
-    end
-  end
-
-  describe Parser, '#parse' do
-    it "parses a regular class name" do
-      type = parse("MyClass")
-      expect(type.size).to eq 1
-      expect(type.first).to be_a(Type)
-      expect(type.first.name).to eq "MyClass"
-    end
-
-    it "parses a path reference name" do
-      type = parse("A::B")
-      expect(type.size).to eq 1
-      expect(type.first).to be_a(Type)
-      expect(type.first.name).to eq "A::B"
-    end
-
-    it "parses a list of simple names" do
-      type = parse("A, B::C, D, E")
-      expect(type.size).to eq 4
-      expect(type[0].name).to eq "A"
-      expect(type[1].name).to eq "B::C"
-      expect(type[2].name).to eq "D"
-      expect(type[3].name).to eq "E"
-    end
-
-    it "parses a collection type" do
-      type = parse("MyList<String>")
-      expect(type.first).to be_a(CollectionType)
-      expect(type.first.types.size).to eq 1
-      expect(type.first.name).to eq "MyList"
-      expect(type.first.types.first.name).to eq "String"
-    end
-
-    it "allows a collection type without a name" do
-      type = parse("<String>")
-      expect(type.first.name).to eq "Array"
-    end
-
-    it "allows a fixed collection type without a name" do
-      type = parse("(String)")
-      expect(type.first.name).to eq "Array"
-    end
-
-    it "allows a hash collection type without a name" do
-      type = parse("{K=>V}")
-      expect(type.first.name).to eq "Hash"
-    end
-
-    it "does not accept two commas in a row" do
-      parse_fail "A,,B"
-    end
-
-    it "does not accept two types not separated by a comma" do
-      parse_fail "A B"
-    end
-
-    it "does not allow a comma without a following type" do
-      parse_fail "A, "
-    end
-
-    it "fails on any unrecognized character" do
-      parse_fail "$"
-    end
-  end
-
-  describe ".explain" do
-    it "parses an arbitrarily nested collection type" do
-      explain = YARD::Tags::TypesExplainer.explain("Array<String, Array<Symbol, List(String, {K=>V})>>")
-      result = "an Array of (Strings or an Array of (Symbols or a List containing
-        (a String followed by a Hash with keys made of (K's) and values of (V's))))"
-      expect(explain).to eq result.delete("\n").squeeze(' ')
-    end
-
-    it "parses various examples" do
-      expect = {
-        "Fixnum, Foo, Object, true" => "a Fixnum; a Foo; an Object; true",
-        "#read" => "an object that responds to #read",
-        "Array<String, Symbol, #read>" => "an Array of (Strings, Symbols or objects that respond to #read)",
-        "Set<Number>" => "a Set of (Numbers)",
-        "Array(String, Symbol)" => "an Array containing (a String followed by a Symbol)",
-        "Hash{String => Symbol, Number}" => "a Hash with keys made of (Strings) and values of (Symbols or Numbers)",
-        "Array<Foo, Bar>, List(String, Symbol, #to_s), {Foo, Bar => Symbol, Number}" => "an Array of (Foos or Bars);
-          a List containing (a String followed by a Symbol followed by an object that responds to #to_s);
-          a Hash with keys made of (Foos or Bars) and values of (Symbols or Numbers)",
-        "#weird_method?, #<=>, #!=" => "an object that responds to #weird_method?;
-          an object that responds to #<=>;
-          an object that responds to #!="
-      }
-      expect.each do |input, expected|
-        explain = YARD::Tags::TypesExplainer.explain(input)
-        expect(explain).to eq expected.delete("\n").squeeze(' ')
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+RSpec.describe YARD::Tags::TypesExplainer do
+  Type = YARD::Tags::TypesExplainer::Type
+  CollectionType = YARD::Tags::TypesExplainer::CollectionType
+  FixedCollectionType = YARD::Tags::TypesExplainer::FixedCollectionType
+  HashCollectionType = YARD::Tags::TypesExplainer::HashCollectionType
+  Parser = YARD::Tags::TypesExplainer::Parser
+
+  def parse(types)
+    Parser.new(types).parse
+  end
+
+  def parse_fail(types)
+    expect(lambda { parse(types) }).to raise_error(SyntaxError)
+  end
+
+  describe Type, '#to_s' do
+    before { @t = Type.new(nil) }
+
+    it "works for a class/module reference" do
+      @t.name = "ClassModuleName"
+      expect(@t.to_s).to eq "a ClassModuleName"
+      expect(@t.to_s(false)).to eq "ClassModuleNames"
+
+      @t.name = "XYZ"
+      expect(@t.to_s).to eq "a XYZ"
+      expect(@t.to_s(false)).to eq "XYZ's"
+
+      @t.name = "Array"
+      expect(@t.to_s).to eq "an Array"
+      expect(@t.to_s(false)).to eq "Arrays"
+    end
+
+    it "works for a method (ducktype)" do
+      @t.name = "#mymethod"
+      expect(@t.to_s).to eq "an object that responds to #mymethod"
+      expect(@t.to_s(false)).to eq "objects that respond to #mymethod"
+    end
+
+    it "works for a constant value" do
+      ['false', 'true', 'nil', '4'].each do |name|
+        @t.name = name
+        expect(@t.to_s).to eq name
+        expect(@t.to_s(false)).to eq name
+      end
+    end
+  end
+
+  describe CollectionType, '#to_s' do
+    before { @t = CollectionType.new("Array", nil) }
+
+    it "can contain one item" do
+      @t.types = [Type.new("Object")]
+      expect(@t.to_s).to eq "an Array of (Objects)"
+    end
+
+    it "can contain more than one item" do
+      @t.types = [Type.new("Object"), Type.new("String"), Type.new("Symbol")]
+      expect(@t.to_s).to eq "an Array of (Objects, Strings or Symbols)"
+    end
+
+    it "can contain nested collections" do
+      @t.types = [CollectionType.new("List", [Type.new("Object")])]
+      expect(@t.to_s).to eq "an Array of (a List of (Objects))"
+    end
+  end
+
+  describe FixedCollectionType, '#to_s' do
+    before { @t = FixedCollectionType.new("Array", nil) }
+
+    it "can contain one item" do
+      @t.types = [Type.new("Object")]
+      expect(@t.to_s).to eq "an Array containing (an Object)"
+    end
+
+    it "can contain more than one item" do
+      @t.types = [Type.new("Object"), Type.new("String"), Type.new("Symbol")]
+      expect(@t.to_s).to eq "an Array containing (an Object followed by a String followed by a Symbol)"
+    end
+
+    it "can contain nested collections" do
+      @t.types = [FixedCollectionType.new("List", [Type.new("Object")])]
+      expect(@t.to_s).to eq "an Array containing (a List containing (an Object))"
+    end
+  end
+
+  describe FixedCollectionType, '#to_s' do
+    before { @t = HashCollectionType.new("Hash", nil, nil) }
+
+    it "can contain a single key type and value type" do
+      @t.key_types = [Type.new("Object")]
+      @t.value_types = [Type.new("Object")]
+      expect(@t.to_s).to eq "a Hash with keys made of (Objects) and values of (Objects)"
+    end
+
+    it "can contain multiple key types" do
+      @t.key_types = [Type.new("Key"), Type.new("String")]
+      @t.value_types = [Type.new("Object")]
+      expect(@t.to_s).to eq "a Hash with keys made of (Keys or Strings) and values of (Objects)"
+    end
+
+    it "can contain multiple value types" do
+      @t.key_types = [Type.new("String")]
+      @t.value_types = [Type.new("true"), Type.new("false")]
+      expect(@t.to_s).to eq "a Hash with keys made of (Strings) and values of (true or false)"
+    end
+  end
+
+  describe Parser, '#parse' do
+    it "parses a regular class name" do
+      type = parse("MyClass")
+      expect(type.size).to eq 1
+      expect(type.first).to be_a(Type)
+      expect(type.first.name).to eq "MyClass"
+    end
+
+    it "parses a path reference name" do
+      type = parse("A::B")
+      expect(type.size).to eq 1
+      expect(type.first).to be_a(Type)
+      expect(type.first.name).to eq "A::B"
+    end
+
+    it "parses a list of simple names" do
+      type = parse("A, B::C, D, E")
+      expect(type.size).to eq 4
+      expect(type[0].name).to eq "A"
+      expect(type[1].name).to eq "B::C"
+      expect(type[2].name).to eq "D"
+      expect(type[3].name).to eq "E"
+    end
+
+    it "parses a collection type" do
+      type = parse("MyList<String>")
+      expect(type.first).to be_a(CollectionType)
+      expect(type.first.types.size).to eq 1
+      expect(type.first.name).to eq "MyList"
+      expect(type.first.types.first.name).to eq "String"
+    end
+
+    it "allows a collection type without a name" do
+      type = parse("<String>")
+      expect(type.first.name).to eq "Array"
+    end
+
+    it "allows a fixed collection type without a name" do
+      type = parse("(String)")
+      expect(type.first.name).to eq "Array"
+    end
+
+    it "allows a hash collection type without a name" do
+      type = parse("{K=>V}")
+      expect(type.first.name).to eq "Hash"
+    end
+
+    it "does not accept two commas in a row" do
+      parse_fail "A,,B"
+    end
+
+    it "does not accept two types not separated by a comma" do
+      parse_fail "A B"
+    end
+
+    it "does not allow a comma without a following type" do
+      parse_fail "A, "
+    end
+
+    it "fails on any unrecognized character" do
+      parse_fail "$"
+    end
+  end
+
+  describe ".explain" do
+    it "parses an arbitrarily nested collection type" do
+      explain = YARD::Tags::TypesExplainer.explain("Array<String, Array<Symbol, List(String, {K=>V})>>")
+      result = "an Array of (Strings or an Array of (Symbols or a List containing
+        (a String followed by a Hash with keys made of (K's) and values of (V's))))"
+      expect(explain).to eq result.delete("\n").squeeze(' ')
+    end
+
+    it "parses various examples" do
+      expect = {
+        "Fixnum, Foo, Object, true" => "a Fixnum; a Foo; an Object; true",
+        "#read" => "an object that responds to #read",
+        "Array<String, Symbol, #read>" => "an Array of (Strings, Symbols or objects that respond to #read)",
+        "Set<Number>" => "a Set of (Numbers)",
+        "Array(String, Symbol)" => "an Array containing (a String followed by a Symbol)",
+        "Hash{String => Symbol, Number}" => "a Hash with keys made of (Strings) and values of (Symbols or Numbers)",
+        "Array<Foo, Bar>, List(String, Symbol, #to_s), {Foo, Bar => Symbol, Number}" => "an Array of (Foos or Bars);
+          a List containing (a String followed by a Symbol followed by an object that responds to #to_s);
+          a Hash with keys made of (Foos or Bars) and values of (Symbols or Numbers)",
+        "#weird_method?, #<=>, #!=" => "an object that responds to #weird_method?;
+          an object that responds to #<=>;
+          an object that responds to #!="
+      }
+      expect.each do |input, expected|
+        explain = YARD::Tags::TypesExplainer.explain(input)
+        expect(explain).to eq expected.delete("\n").squeeze(' ')
+      end
+    end
+  end
+end