dry-types 1.0.1 → 1.1.0

data/lib/dry/types/coercions/params.rb

@@ -71,8 +71,8 @@ module Dry
           else
             Integer(input)
           end
-        rescue ArgumentError, TypeError => error
-          CoercionError.handle(error, &block)
+        rescue ArgumentError, TypeError => e
+          CoercionError.handle(e, &block)
         end
 
         # @param [#to_f, Object] input
@@ -84,8 +84,8 @@ module Dry
         # @api public
         def self.to_float(input, &block)
           Float(input)
-        rescue ArgumentError, TypeError => error
-          CoercionError.handle(error, &block)
+        rescue ArgumentError, TypeError => e
+          CoercionError.handle(e, &block)
         end
 
         # @param [#to_d, Object] input

data/lib/dry/types/constrained.rb

@@ -126,6 +126,11 @@ module Dry
         [:constrained, [type.to_ast(meta: meta), rule.to_ast]]
       end
 
+      # @api private
+      def constructor_type
+        type.constructor_type
+      end
+
       private
 
       # @param [Object] response

data/lib/dry/types/constructor.rb

@@ -95,8 +95,8 @@ module Dry
       # @api public
       def try(input, &block)
         value = fn.(input)
-      rescue CoercionError => error
-        failure = failure(input, error)
+      rescue CoercionError => e
+        failure = failure(input, e)
         block_given? ? yield(failure) : failure
       else
         type.try(value, &block)
@@ -184,7 +184,7 @@ module Dry
         if type.respond_to?(method)
           response = type.__send__(method, *args, &block)
 
-          if composable?(response)
+          if response.is_a?(Type) && type.class == response.class
             response.constructor_type.new(response, options)
           else
             response
@@ -193,11 +193,6 @@ module Dry
           super
         end
       end
-
-      # @api private
-      def composable?(value)
-        value.is_a?(Builder)
-      end
     end
   end
 end

data/lib/dry/types/constructor/function.rb

@@ -1,4 +1,3 @@
-
 # frozen_string_literal: true
 
 require 'concurrent/map'
@@ -16,8 +15,8 @@ module Dry
         class Safe < Function
           def call(input, &block)
             @fn.(input, &block)
-          rescue NoMethodError, TypeError, ArgumentError => error
-            CoercionError.handle(error, &block)
+          rescue NoMethodError, TypeError, ArgumentError => e
+            CoercionError.handle(e, &block)
           end
         end
 
@@ -91,8 +90,8 @@ module Dry
           class PrivateSafeCall < PrivateCall
             def call(input, &block)
               @target.send(@name, input)
-            rescue NoMethodError, TypeError, ArgumentError => error
-              CoercionError.handle(error, &block)
+            rescue NoMethodError, TypeError, ArgumentError => e
+              CoercionError.handle(e, &block)
             end
           end
 

data/lib/dry/types/core.rb

@@ -5,7 +5,7 @@ require 'dry/types/any'
 module Dry
   module Types
     # Primitives with {Kernel} coercion methods
-    COERCIBLE = {
+    KERNEL_COERCIBLE = {
       string: String,
       integer: Integer,
       float: Float,
@@ -14,10 +14,19 @@ module Dry
       hash: ::Hash
     }.freeze
 
-    # Primitives that are non-coercible through {Kernel} methods
+    # Primitives with coercions through by convention `to_*` methods
+    METHOD_COERCIBLE = {
+      symbol: Symbol
+    }.freeze
+
+    # By convention methods to coerce {METHOD_COERCIBLE} primitives
+    METHOD_COERCIBLE_METHODS = {
+      symbol: :to_sym
+    }.freeze
+
+    # Primitives that are non-coercible
     NON_COERCIBLE = {
       nil: NilClass,
-      symbol: Symbol,
       class: Class,
       true: TrueClass,
       false: FalseClass,
@@ -28,7 +37,10 @@ module Dry
     }.freeze
 
     # All built-in primitives
-    ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).freeze
+    ALL_PRIMITIVES = [KERNEL_COERCIBLE, METHOD_COERCIBLE, NON_COERCIBLE].reduce(&:merge).freeze
+
+    # All coercible types
+    COERCIBLE = KERNEL_COERCIBLE.merge(METHOD_COERCIBLE).freeze
 
     # All built-in primitives except {NilClass}
     NON_NIL = ALL_PRIMITIVES.reject { |name, _| name == :nil }.freeze
@@ -46,11 +58,18 @@ module Dry
       register("strict.#{name}", type)
     end
 
-    # Register {COERCIBLE} types
-    COERCIBLE.each do |name, primitive|
+    # Register {KERNEL_COERCIBLE} types
+    KERNEL_COERCIBLE.each do |name, primitive|
       register("coercible.#{name}", self["nominal.#{name}"].constructor(Kernel.method(primitive.name)))
     end
 
+    # Register {METHOD_COERCIBLE} types
+    METHOD_COERCIBLE.each_key do |name|
+      register(
+        "coercible.#{name}", self["nominal.#{name}"].constructor(&METHOD_COERCIBLE_METHODS[name])
+      )
+    end
+
     # Register optional strict {NON_NIL} types
     NON_NIL.each_key do |name|
       register("optional.strict.#{name}", self["strict.#{name}"].optional)
@@ -64,8 +83,8 @@ module Dry
     # Register `:bool` since it's common and not a built-in Ruby type :(
     register('nominal.bool', self['nominal.true'] | self['nominal.false'])
     bool = self['strict.true'] | self['strict.false']
-    register("strict.bool", bool)
-    register("bool", bool)
+    register('strict.bool', bool)
+    register('bool', bool)
 
     register('any', Any)
     register('nominal.any', Any)

data/lib/dry/types/enum.rb

@@ -11,6 +11,7 @@ module Dry
       include Type
       include Dry::Equalizer(:type, :mapping, inspect: false)
       include Decorator
+      include Builder
 
       # @return [Array]
       attr_reader :values

data/lib/dry/types/extensions/maybe.rb

@@ -79,7 +79,7 @@ module Dry
       # @api public
       def default(value)
         if value.nil?
-          raise ArgumentError, "nil cannot be used as a default of a maybe type"
+          raise ArgumentError, 'nil cannot be used as a default of a maybe type'
         else
           super
         end
@@ -97,6 +97,14 @@ module Dry
       end
     end
 
+    # @api private
+    class Schema::Key
+      # @api private
+      def maybe
+        __new__(type.maybe)
+      end
+    end
+
     # @api private
     class Printer
       MAPPING[Maybe] = :visit_maybe

data/lib/dry/types/hash.rb

@@ -50,8 +50,8 @@ module Dry
 
       # @api private
       def weak(*)
-        raise "Support for old hash schemas was removed, please refer to the CHANGELOG "\
-              "on how to proceed with the new API https://github.com/dry-rb/dry-types/blob/master/CHANGELOG.md"
+        raise 'Support for old hash schemas was removed, please refer to the CHANGELOG '\
+              'on how to proceed with the new API https://github.com/dry-rb/dry-types/blob/master/CHANGELOG.md'
       end
       alias_method :permissive, :weak
       alias_method :strict, :weak
@@ -69,9 +69,7 @@ module Dry
       def with_type_transform(proc = nil, &block)
         fn = proc || block
 
-        if fn.nil?
-          raise ArgumentError, "a block or callable argument is required"
-        end
+        raise ArgumentError, 'a block or callable argument is required' if fn.nil?
 
         handle = Dry::Types::FnContainer.register(fn)
         with(type_transform_fn: handle)
@@ -97,11 +95,11 @@ module Dry
       #
       # @api public
       def to_ast(meta: true)
-        if RUBY_VERSION >= "2.5"
-          opts = options.slice(:type_transform_fn)
-        else
-          opts = options.select { |k, _| k == :type_transform_fn }
-        end
+        opts = if RUBY_VERSION >= '2.5'
+                 options.slice(:type_transform_fn)
+               else
+                 options.select { |k, _| k == :type_transform_fn }
+               end
 
         [:hash, [opts, meta ? self.meta : EMPTY_HASH]]
       end

data/lib/dry/types/hash/constructor.rb

@@ -21,11 +21,11 @@ module Dry
           type.lax.constructor(fn, meta: meta)
         end
 
-        private
-
-        # @api private
-        def composable?(value)
-          super && !value.is_a?(Schema::Key)
+        # @see Dry::Types::Array#of
+        #
+        # @api public
+        def schema(*args)
+          type.schema(*args).constructor(fn, meta: meta)
         end
       end
     end

data/lib/dry/types/json.rb

@@ -24,6 +24,10 @@ module Dry
       self['nominal.decimal'].constructor(Coercions::JSON.method(:to_decimal))
     end
 
+    register('json.symbol') do
+      self['nominal.symbol'].constructor(Coercions::JSON.method(:to_symbol))
+    end
+
     register('json.array') { self['array'] }
 
     register('json.hash') { self['hash'] }

data/lib/dry/types/lax.rb

@@ -40,8 +40,8 @@ module Dry
       # @api public
       def try(input, &block)
         type.try(input, &block)
-      rescue CoercionError => error
-        result = failure(input, error.message)
+      rescue CoercionError => e
+        result = failure(input, e.message)
         block ? yield(result) : result
       end
 
@@ -67,7 +67,7 @@ module Dry
       #
       # @api private
       def decorate?(response)
-        super || response.is_a?(constructor_type)
+        super || response.is_a?(type.constructor_type)
       end
     end
 

data/lib/dry/types/map.rb

@@ -74,6 +74,7 @@ module Dry
       def try(hash)
         result = coerce(hash)
         return result if result.success? || !block_given?
+
         yield(result)
       end
 
@@ -100,11 +101,14 @@ module Dry
 
       # @api private
       def coerce(input)
-        return failure(
-          input, CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
-        ) unless primitive?(input)
+        unless primitive?(input)
+          return failure(
+            input, CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
+          )
+        end
 
-        output, failures = {}, []
+        output = {}
+        failures = []
 
         input.each do |k, v|
           res_k = key_type.try(k)

data/lib/dry/types/module.rb

@@ -31,7 +31,7 @@ module Dry
             base.instance_exec(const_get(:Nominal, false)) do |nominal|
               extend Dry::Core::Deprecations[:'dry-types']
               const_set(:Definition, nominal)
-              deprecate_constant(:Definition, message: "Nominal")
+              deprecate_constant(:Definition, message: 'Nominal')
             end
           end
         end
@@ -93,8 +93,8 @@ module Dry
 
         (referenced.uniq - known).each do |name|
           raise ArgumentError,
-                "#{ name.inspect } is not a known type namespace. "\
-                "Supported options are #{ known.map(&:inspect).join(', ') }"
+                "#{name.inspect} is not a known type namespace. "\
+                "Supported options are #{known.map(&:inspect).join(', ')}"
         end
       end
 

data/lib/dry/types/nominal.rb

@@ -126,9 +126,8 @@ module Dry
       #
       # @api public
       def failure(input, error)
-        unless error.is_a?(CoercionError)
-          raise ArgumentError, "error must be a CoercionError"
-        end
+        raise ArgumentError, 'error must be a CoercionError' unless error.is_a?(CoercionError)
+
         Result::Failure.new(input, error)
       end
 
@@ -202,7 +201,7 @@ module Dry
 
     extend Dry::Core::Deprecations[:'dry-types']
     Definition = Nominal
-    deprecate_constant(:Definition, message: "Nominal")
+    deprecate_constant(:Definition, message: 'Nominal')
   end
 end
 

data/lib/dry/types/params.rb

@@ -51,5 +51,9 @@ module Dry
     register('params.hash') do
       self['nominal.hash'].constructor(Coercions::Params.method(:to_hash))
     end
+
+    register('params.symbol') do
+      self['nominal.symbol'].constructor(Coercions::Params.method(:to_symbol))
+    end
   end
 end

data/lib/dry/types/printer.rb

@@ -8,6 +8,7 @@ module Dry
         Nominal => :visit_nominal,
         Constructor => :visit_constructor,
         Hash::Constructor => :visit_constructor,
+        Array::Constructor => :visit_constructor,
         Constrained => :visit_constrained,
         Constrained::Coercible => :visit_constrained,
         Hash => :visit_hash,
@@ -26,7 +27,7 @@ module Dry
       }
 
       def call(type)
-        output = "".dup
+        output = ''.dup
         visit(type) { |str| output << str }
         "#<Dry::Types[#{output}]>"
       end
@@ -43,11 +44,11 @@ module Dry
       end
 
       def visit_any(_)
-        yield "Any"
+        yield 'Any'
       end
 
       def visit_array(_)
-         yield "Array"
+        yield 'Array'
       end
 
       def visit_array_member(array)
@@ -74,7 +75,7 @@ module Dry
           options = constrained.options.dup
           rule = options.delete(:rule)
 
-          visit_options(options) do |opts|
+          visit_options(options) do |_opts|
             yield "Constrained<#{type} rule=[#{rule}]>"
           end
         end
@@ -110,7 +111,7 @@ module Dry
           header = "Schema<#{schema_parameters}keys={"
 
           if size.zero?
-            yield "#{ header}}>"
+            yield "#{header}}>"
           else
             yield header.dup << keys.map { |key|
               visit(key) { |type| type }
@@ -126,7 +127,7 @@ module Dry
             options.delete(:key_type)
             options.delete(:value_type)
 
-            visit_options(options) do |opts|
+            visit_options(options) do |_opts|
               yield "Map<#{key} => #{value}>"
             end
           end
@@ -193,7 +194,7 @@ module Dry
               yield "Enum<#{type} values={#{values}}#{opts}>"
             else
               mapping_str = mapping.map { |key, value|
-                "#{ key.inspect }=>#{value.inspect}"
+                "#{key.inspect}=>#{value.inspect}"
               }.join(', ')
               yield "Enum<#{type} mapping={#{mapping_str}}#{opts}>"
             end
@@ -251,14 +252,14 @@ module Dry
 
         case fn
         when Method
-          yield "#{ fn.receiver }.#{ fn.name }"
+          yield "#{fn.receiver}.#{fn.name}"
         when Proc
           path, line = fn.source_location
 
-          if line && line.zero?
+          if line&.zero?
             yield ".#{path}"
           elsif path
-            yield "#{path.sub(Dir.pwd + '/', EMPTY_STRING) }:#{line}"
+            yield "#{path.sub(Dir.pwd + '/', EMPTY_STRING)}:#{line}"
           elsif fn.lambda?
             yield '(lambda)'
           else