Refactor: Extract Litral & Duck type classes

This could be useful for solargraph gem

Author: lekemula

lib/yard/tags/types_explainer.rb

@@ -31,18 +31,14 @@ def initialize(name)
         end
 
         def to_s(singular = true)
-          if name[0, 1] == "#"
-            singular ? "an object that responds to #{name}" : "objects that respond to #{name}"
-          elsif name[0, 1] == ":" || (name[0, 1] =~ /['"]/ && name[-1, 1] =~ /['"]/)
-            "a literal value #{name}"
-          elsif name[0, 1] =~ /[A-Z]/
+          if name[0, 1] =~ /[A-Z]/
             singular ? "a#{name[0, 1] =~ /[aeiou]/i ? 'n' : ''} " + name : "#{name}#{name[-1, 1] =~ /[A-Z]/ ? "'" : ''}s"
           else
             name
           end
         end
 
-        private
+        protected
 
         def list_join(list)
           index = 0
@@ -56,6 +52,20 @@ def list_join(list)
         end
       end
 
+      # @private
+      class LiteralType < Type
+        def to_s(_singular = true)
+          "a literal value #{name}"
+        end
+      end
+
+      # @private
+      class DuckType < Type
+        def to_s(singular = true)
+          singular ? "an object that responds to #{name}" : "objects that respond to #{name}"
+        end
+      end
+
       # @private
       class CollectionType < Type
         attr_accessor :types
@@ -137,7 +147,7 @@ def parse
                 name = token
               when :type_next
                 raise SyntaxError, "expecting name, got '#{token}' at #{@scanner.pos}" if name.nil?
-                type = Type.new(name) unless type
+                type = create_type(name) unless type
                 types << type
                 type = nil
                 name = nil
@@ -150,14 +160,26 @@ def parse
                 type = HashCollectionType.new(name, parse, parse)
               when :hash_collection_next, :hash_collection_end, :fixed_collection_end, :collection_end, :parse_end
                 raise SyntaxError, "expecting name, got '#{token}'" if name.nil?
-                type = Type.new(name) unless type
+                type = create_type(name) unless type
                 types << type
                 return types
               end
             end
             raise SyntaxError, "invalid character at #{@scanner.peek(1)}" unless found
           end
         end
+
+        private
+
+        def create_type(name)
+          if name[0, 1] == ":" || (name[0, 1] =~ /['"]/ && name[-1, 1] =~ /['"]/)
+            LiteralType.new(name)
+          elsif name[0, 1] == "#"
+            DuckType.new(name)
+          else
+            Type.new(name)
+          end
+        end
       end
     end
   end

spec/tags/types_explainer_spec.rb

@@ -2,6 +2,8 @@
 
 RSpec.describe YARD::Tags::TypesExplainer do
   Type = YARD::Tags::TypesExplainer::Type
+  LiteralType = YARD::Tags::TypesExplainer::LiteralType
+  DuckType = YARD::Tags::TypesExplainer::DuckType
   CollectionType = YARD::Tags::TypesExplainer::CollectionType
   FixedCollectionType = YARD::Tags::TypesExplainer::FixedCollectionType
   HashCollectionType = YARD::Tags::TypesExplainer::HashCollectionType
@@ -32,25 +34,29 @@ def parse_fail(types)
       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 DuckType, '#to_s' do
+    it "works for a method (ducktype)" do
+      duck_type = DuckType.new("#mymethod")
+      expect(duck_type.to_s).to eq "an object that responds to #mymethod"
+      expect(duck_type.to_s(false)).to eq "objects that respond to #mymethod"
+    end
+  end
 
+  describe LiteralType, '#to_s' do
     it "works for literal values" do
       [':symbol', "'5'"].each do |name|
-        @t.name = name
-        expect(@t.to_s).to eq "a literal value #{name}"
-        expect(@t.to_s(false)).to eq "a literal value #{name}"
+        literal_type = LiteralType.new(name)
+        expect(literal_type.to_s).to eq "a literal value #{name}"
+        expect(literal_type.to_s(false)).to eq "a literal value #{name}"
       end
     end
   end
@@ -93,7 +99,7 @@ def parse_fail(types)
     end
   end
 
-  describe FixedCollectionType, '#to_s' do
+  describe HashCollectionType, '#to_s' do
     before { @t = HashCollectionType.new("Hash", nil, nil) }
 
     it "can contain a single key type and value type" do