feat: add RespondTo type

README.md

@@ -73,6 +73,15 @@ sig validate: T.Boolean
 def create(validate:); end
 ```
 
+#### `RespondTo`
+
+Value **MUST** be respond to the given method(s).
+
+```ruby
+sig name: T.RespondTo(:to_s)
+def create(name:); end
+```
+
 #### `Any`
 
 Value **MUST** be any of the given list of values, that is, the value must be one of the given list.

lib/delivered/signature.rb

@@ -34,7 +34,7 @@ def sig(*sig_args, **sig_kwargs, &return_blk)
           args[i] => ^arg
         rescue NoMatchingPatternError => e
           raise Delivered::ArgumentError,
-                "`#{cname}` expected `#{arg}` as positional arg #{i}, but received " \
+                "`#{cname}` expected #{arg.inspect} as argument #{i}, but received " \
                 "`#{args[i].inspect}`",
                 caller, cause: e
         end
@@ -43,8 +43,8 @@ def sig(*sig_args, **sig_kwargs, &return_blk)
           value => ^(sig_kwargs[key])
         rescue NoMatchingPatternError => e
           raise Delivered::ArgumentError,
-                "`#{cname}` expected `#{sig_kwargs[key]}` as keyword arg :#{key}, but received " \
-                "`#{value.inspect}`",
+                "`#{cname}` expected #{sig_kwargs[key].inspect} as keyword argument :#{key}, " \
+                "but received `#{value.inspect}`",
                 caller, cause: e
         end
 
@@ -58,7 +58,8 @@ def sig(*sig_args, **sig_kwargs, &return_blk)
           result => ^returns unless returns.nil?
         rescue NoMatchingPatternError => e
           raise Delivered::ArgumentError,
-                "`#{cname}` expected to return `#{returns}`, but returned `#{result.inspect}`",
+                "`#{cname}` expected to return #{returns.inspect}, " \
+                "but returned `#{result.inspect}`",
                 caller, cause: e
         end
 

lib/delivered/types.rb

@@ -6,16 +6,32 @@ def initialize(*types)
       @types = types
     end
 
+    def inspect = "Any(#{@types.map(&:inspect).join(', ')})"
+
     def ===(value)
       @types.empty? ? true : @types.any? { |type| type === value }
     end
   end
 
+  class RespondToType
+    def initialize(*methods)
+      @methods = methods
+    end
+
+    def inspect = "RespondTo(#{@methods.map(&:inspect).join(', ')})"
+
+    def ===(value)
+      @methods.all? { |m| value.respond_to?(m) }
+    end
+  end
+
   class NilableType
     def initialize(type = nil)
       @type = type
     end
 
+    def inspect = "Nilable(#{@type&.inspect || 'Any'})"
+
     def ===(value)
       (@type.nil? ? true : nil === value) || @type === value
     end
@@ -26,6 +42,8 @@ def initialize
       freeze
     end
 
+    def inspect = 'Boolean'
+
     def ===(value)
       [true, false].include?(value)
     end
@@ -35,6 +53,7 @@ module Types
     module_function
 
     def Nilable(type = nil) = NilableType.new(type)
+    def RespondTo(*methods) = RespondToType.new(*methods)
     def Any(*types) = AnyType.new(*types)
     def Boolean = BooleanType.new
   end

test/delivered/types.rb

@@ -13,7 +13,7 @@
     end
 
     with 'arguments' do
-      it 'one of given arg' do
+      it 'is one of given arg' do
         assert T.Any(:one, :two) === :one
         assert T.Any(String, Integer) === 'one'
         assert T.Any(String, Integer) === 1
@@ -32,6 +32,17 @@
     end
   end
 
+  describe 'RespondTo' do
+    it 'should respond to given method' do
+      assert T.RespondTo(:to_s) === 'foo'
+      assert T.RespondTo(:to_s, :to_i) === 'foo'
+    end
+
+    it 'raises when not respond to' do
+      expect { :foo => ^(T.RespondTo(:bar)) }.to raise_exception NoMatchingPatternError
+    end
+  end
+
   describe 'Boolean' do
     it 'should be true or false' do
       assert T.Boolean === true