dry-types 1.2.1 → 1.5.0

data/lib/dry/types/builder_methods.rb

@@ -4,7 +4,6 @@ module Dry
   module Types
     # Common API for building type objects in a convenient way
     #
-    # rubocop:disable Naming/MethodName
     #
     # @api public
     module BuilderMethods
@@ -83,7 +82,11 @@ module Dry
       # @return [Dry::Types::Type]
       def Constructor(klass, cons = nil, &block)
         if klass.is_a?(Type)
-          klass.constructor(cons || block || klass.method(:new))
+          if cons || block
+            klass.constructor(cons || block)
+          else
+            klass
+          end
         else
           Nominal(klass).constructor(cons || block || klass.method(:new))
         end
@@ -129,7 +132,7 @@ module Dry
       #
       # @return [Dry::Types::Contrained]
       def Interface(*methods)
-        methods.reduce(Types['nominal.any']) do |type, method|
+        methods.reduce(Types["nominal.any"]) do |type, method|
           type.constrained(respond_to: method)
         end
       end

data/lib/dry/types/coercions.rb

@@ -8,23 +8,6 @@ module Dry
     module Coercions
       include Dry::Core::Constants
 
-      # @param [String, Object] input
-      #
-      # @return [nil] if the input is an empty string or nil
-      #
-      # @raise CoercionError
-      #
-      # @api public
-      def to_nil(input, &_block)
-        if input.nil? || empty_str?(input)
-          nil
-        elsif block_given?
-          yield
-        else
-          raise CoercionError, "#{input.inspect} is not nil"
-        end
-      end
-
       # @param [#to_str, Object] input
       #
       # @return [Date, Object]
@@ -39,6 +22,8 @@ module Dry
           rescue ArgumentError, RangeError => e
             CoercionError.handle(e, &block)
           end
+        elsif input.is_a?(::Date)
+          input
         elsif block_given?
           yield
         else
@@ -60,6 +45,8 @@ module Dry
           rescue ArgumentError => e
             CoercionError.handle(e, &block)
           end
+        elsif input.is_a?(::DateTime)
+          input
         elsif block_given?
           yield
         else
@@ -81,6 +68,8 @@ module Dry
           rescue ArgumentError => e
             CoercionError.handle(e, &block)
           end
+        elsif input.is_a?(::Time)
+          input
         elsif block_given?
           yield
         else

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'bigdecimal'
-require 'bigdecimal/util'
-require 'time'
+require "date"
+require "bigdecimal"
+require "bigdecimal/util"
+require "time"
 
 module Dry
   module Types
@@ -14,6 +14,23 @@ module Dry
       module JSON
         extend Coercions
 
+        # @param [Object] input
+        #
+        # @return [nil] if the input is nil
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_nil(input, &_block)
+          if input.nil?
+            nil
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} is not nil"
+          end
+        end
+
         # @param [#to_d, Object] input
         #
         # @return [BigDecimal,nil]
@@ -21,7 +38,7 @@ module Dry
         # @raise CoercionError
         #
         # @api public
-        def self.to_decimal(input, &block)
+        def self.to_decimal(input, &_block)
           if input.is_a?(::Float)
             input.to_d
           else

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'bigdecimal'
-require 'bigdecimal/util'
+require "bigdecimal"
+require "bigdecimal/util"
 
 module Dry
   module Types
@@ -14,10 +14,27 @@ module Dry
         FALSE_VALUES = %w[0 off Off OFF f false False FALSE F n no No NO N].freeze
         BOOLEAN_MAP = ::Hash[
           TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])
-        ].freeze
+        ].merge(true => true, false => false).freeze
 
         extend Coercions
 
+        # @param [Object] input
+        #
+        # @return [nil] if the input is an empty string or nil
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_nil(input, &_block)
+          if input.nil? || empty_str?(input)
+            nil
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} is not nil"
+          end
+        end
+
         # @param [String, Object] input
         #
         # @return [Boolean,Object]
@@ -95,7 +112,7 @@ module Dry
         # @raise CoercionError
         #
         # @api public
-        def self.to_decimal(input, &block)
+        def self.to_decimal(input, &_block)
           to_float(input) do
             if block_given?
               return yield

data/lib/dry/types/compiler.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/core/deprecations'
+require "dry/core/deprecations"
 
 module Dry
   module Types
@@ -63,37 +63,37 @@ module Dry
       def visit_array(node)
         member, meta = node
         member = member.is_a?(Class) ? member : visit(member)
-        registry['nominal.array'].of(member).meta(meta)
+        registry["nominal.array"].of(member).meta(meta)
       end
 
       def visit_hash(node)
         opts, meta = node
-        registry['nominal.hash'].with(**opts, meta: meta)
+        registry["nominal.hash"].with(**opts, meta: meta)
       end
 
       def visit_schema(node)
         keys, options, meta = node
-        registry['nominal.hash'].schema(keys.map { |key| visit(key) }).with(**options, meta: meta)
+        registry["nominal.hash"].schema(keys.map { |key| visit(key) }).with(**options, meta: meta)
       end
 
       def visit_json_hash(node)
         keys, meta = node
-        registry['json.hash'].schema(keys.map { |key| visit(key) }, meta)
+        registry["json.hash"].schema(keys.map { |key| visit(key) }, meta)
       end
 
       def visit_json_array(node)
         member, meta = node
-        registry['json.array'].of(visit(member)).meta(meta)
+        registry["json.array"].of(visit(member)).meta(meta)
       end
 
       def visit_params_hash(node)
         keys, meta = node
-        registry['params.hash'].schema(keys.map { |key| visit(key) }, meta)
+        registry["params.hash"].schema(keys.map { |key| visit(key) }, meta)
       end
 
       def visit_params_array(node)
         member, meta = node
-        registry['params.array'].of(visit(member)).meta(meta)
+        registry["params.array"].of(visit(member)).meta(meta)
       end
 
       def visit_key(node)
@@ -108,11 +108,11 @@ module Dry
 
       def visit_map(node)
         key_type, value_type, meta = node
-        registry['nominal.hash'].map(visit(key_type), visit(value_type)).meta(meta)
+        registry["nominal.hash"].map(visit(key_type), visit(value_type)).meta(meta)
       end
 
       def visit_any(meta)
-        registry['any'].meta(meta)
+        registry["any"].meta(meta)
       end
 
       def compile_fn(fn)

data/lib/dry/types/constrained.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'dry/types/decorator'
-require 'dry/types/constraints'
-require 'dry/types/constrained/coercible'
+require "dry/types/decorator"
+require "dry/types/constraints"
+require "dry/types/constrained/coercible"
 
 module Dry
   module Types
@@ -14,7 +14,7 @@ module Dry
       include Decorator
       include Builder
       include Printable
-      include Dry::Equalizer(:type, :rule, inspect: false)
+      include Dry::Equalizer(:type, :rule, inspect: false, immutable: true)
 
       # @return [Dry::Logic::Rule]
       attr_reader :rule
@@ -29,11 +29,9 @@ module Dry
         @rule = options.fetch(:rule)
       end
 
-      # @api private
-      #
       # @return [Object]
       #
-      # @api public
+      # @api private
       def call_unsafe(input)
         result = rule.(input)
 
@@ -44,11 +42,9 @@ module Dry
         end
       end
 
-      # @api private
-      #
       # @return [Object]
       #
-      # @api public
+      # @api private
       def call_safe(input, &block)
         if rule[input]
           type.call_safe(input, &block)

data/lib/dry/types/constraints.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'dry/logic/rule_compiler'
-require 'dry/logic/predicates'
-require 'dry/logic/rule/predicate'
+require "dry/logic/rule_compiler"
+require "dry/logic/predicates"
+require "dry/logic/rule/predicate"
 
 module Dry
   # Helper methods for constraint types

data/lib/dry/types/constructor.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'dry/types/fn_container'
-require 'dry/types/constructor/function'
+require "dry/types/fn_container"
+require "dry/types/constructor/function"
+require "dry/types/constructor/wrapper"
 
 module Dry
   module Types
@@ -10,7 +11,7 @@ module Dry
     #
     # @api public
     class Constructor < Nominal
-      include Dry::Equalizer(:type, :options, inspect: false)
+      include Dry::Equalizer(:type, :options, inspect: false, immutable: true)
 
       # @return [#call]
       attr_reader :fn
@@ -30,6 +31,32 @@ module Dry
         super(type, **options, fn: Function[options.fetch(:fn, block)])
       end
 
+      # @param [Builder, Object] input
+      # @param [Hash] options
+      # @param [#call, nil] block
+      #
+      # @api public
+      def self.[](type, fn:, **options)
+        function = Function[fn]
+
+        if function.wrapper?
+          wrapper_type.new(type, fn: function, **options)
+        else
+          new(type, fn: function, **options)
+        end
+      end
+
+      # @api private
+      def self.wrapper_type
+        @wrapper_type ||= begin
+          if self < Wrapper
+            self
+          else
+            const_set(:Wrapping, ::Class.new(self).include(Wrapper))
+          end
+        end
+      end
+
       # Instantiate a new constructor type instance
       #
       # @param [Type] type
@@ -85,7 +112,13 @@ module Dry
       #
       # @api public
       def constructor(new_fn = nil, **options, &block)
-        with(**options, fn: fn >> (new_fn || block))
+        next_fn = Function[new_fn || block]
+
+        if next_fn.wrapper?
+          self.class.wrapper_type.new(with(**options), fn: next_fn)
+        else
+          with(**options, fn: fn >> next_fn)
+        end
       end
       alias_method :append, :constructor
       alias_method :>>, :constructor
@@ -123,7 +156,7 @@ module Dry
       # @return [Lax]
       # @api public
       def lax
-        Lax.new(Constructor.new(type.lax, **options))
+        Lax.new(constructor_type[type.lax, **options])
       end
 
       # Wrap the type with a proc
@@ -157,8 +190,8 @@ module Dry
         if type.respond_to?(method)
           response = type.public_send(method, *args, &block)
 
-          if response.is_a?(Type) && type.class == response.class
-            response.constructor_type.new(response, **options)
+          if response.is_a?(Type) && type.class.equal?(response.class)
+            response.constructor_type[response, **options]
           else
             response
           end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'concurrent/map'
+require "concurrent/map"
 
 module Dry
   module Types
@@ -15,7 +15,7 @@ module Dry
         class Safe < Function
           def call(input, &block)
             @fn.(input, &block)
-          rescue NoMethodError, TypeError, ArgumentError => e
+          rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
             CoercionError.handle(e, &block)
           end
         end
@@ -30,10 +30,14 @@ module Dry
           #
           # @return [Function]
           def self.call_class(method, public, safe)
-            @cache.fetch_or_store([method, public, safe].hash) do
+            @cache.fetch_or_store([method, public, safe]) do
               if public
                 ::Class.new(PublicCall) do
                   include PublicCall.call_interface(method, safe)
+
+                  define_method(:__to_s__) do
+                    "#<PublicCall for :#{method}>"
+                  end
                 end
               elsif safe
                 PrivateCall
@@ -53,7 +57,7 @@ module Dry
             #
             # @return [::Module]
             def self.call_interface(method, safe)
-              @interfaces.fetch_or_store([method, safe].hash) do
+              @interfaces.fetch_or_store([method, safe]) do
                 ::Module.new do
                   if safe
                     module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
@@ -65,7 +69,7 @@ module Dry
                     module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
                       def call(input, &block)
                         @target.#{method}(input)
-                      rescue NoMethodError, TypeError, ArgumentError => error
+                      rescue ::NoMethodError, ::TypeError, ::ArgumentError => error
                         CoercionError.handle(error, &block)
                       end
                     RUBY
@@ -90,7 +94,7 @@ module Dry
           class PrivateSafeCall < PrivateCall
             def call(input, &block)
               @target.send(@name, input)
-            rescue NoMethodError, TypeError, ArgumentError => e
+            rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
               CoercionError.handle(e, &block)
             end
           end
@@ -116,15 +120,31 @@ module Dry
           end
         end
 
+        class Wrapper < Function
+          # @return [Object]
+          def call(input, type, &block)
+            @fn.(input, type, &block)
+          rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
+            CoercionError.handle(e, &block)
+          end
+          alias_method :[], :call
+
+          def arity
+            2
+          end
+        end
+
         # Choose or build specialized invokation code for a callable
         #
         # @param [#call] fn
         # @return [Function]
         def self.[](fn)
-          raise ArgumentError, 'Missing constructor block' if fn.nil?
+          raise ::ArgumentError, "Missing constructor block" if fn.nil?
 
           if fn.is_a?(Function)
             fn
+          elsif fn.respond_to?(:arity) && fn.arity.equal?(2)
+            Wrapper.new(fn)
           elsif fn.is_a?(::Method)
             MethodCall[fn, yields_block?(fn)]
           elsif yields_block?(fn)
@@ -146,7 +166,7 @@ module Dry
           last_arg.equal?(:block)
         end
 
-        include Dry::Equalizer(:fn)
+        include ::Dry::Equalizer(:fn, immutable: true)
 
         attr_reader :fn
 
@@ -160,39 +180,34 @@ module Dry
         end
         alias_method :[], :call
 
+        # @return [Integer]
+        def arity
+          1
+        end
+
+        def wrapper?
+          arity.equal?(2)
+        end
+
         # @return [Array]
         def to_ast
           if fn.is_a?(::Proc)
-            [:id, Dry::Types::FnContainer.register(fn)]
+            [:id, FnContainer.register(fn)]
           else
             [:callable, fn]
           end
         end
 
-        if RUBY_VERSION >= '2.6'
-          # @return [Function]
-          def >>(other)
-            proc = other.is_a?(::Proc) ? other : other.fn
-            Function[@fn >> proc]
-          end
-
-          # @return [Function]
-          def <<(other)
-            proc = other.is_a?(::Proc) ? other : other.fn
-            Function[@fn << proc]
-          end
-        else
-          # @return [Function]
-          def >>(other)
-            proc = other.is_a?(::Proc) ? other : other.fn
-            Function[-> x { proc[@fn[x]] }]
-          end
+        # @return [Function]
+        def >>(other)
+          f = Function[other]
+          Function[-> x, &b { f.(self.(x, &b), &b) }]
+        end
 
-          # @return [Function]
-          def <<(other)
-            proc = other.is_a?(::Proc) ? other : other.fn
-            Function[-> x { @fn[proc[x]] }]
-          end
+        # @return [Function]
+        def <<(other)
+          f = Function[other]
+          Function[-> x, &b { self.(f.(x, &b), &b) }]
         end
       end
     end