dry-types 1.4.0 → 1.5.1

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
@@ -133,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/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
@@ -38,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
@@ -112,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,9 @@
 # frozen_string_literal: true
 
-require 'dry/types/decorator'
-require 'dry/types/constraints'
-require 'dry/types/constrained/coercible'
+require "dry/core/equalizer"
+require "dry/types/decorator"
+require "dry/types/constraints"
+require "dry/types/constrained/coercible"
 
 module Dry
   module Types
@@ -29,11 +30,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 +43,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,9 @@
 # frozen_string_literal: true
 
-require 'dry/types/fn_container'
-require 'dry/types/constructor/function'
+require "dry/core/equalizer"
+require "dry/types/fn_container"
+require "dry/types/constructor/function"
+require "dry/types/constructor/wrapper"
 
 module Dry
   module Types
@@ -30,6 +32,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 +113,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 +157,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 +191,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,7 @@
 # frozen_string_literal: true
 
-require 'concurrent/map'
+require "dry/core/equalizer"
+require "concurrent/map"
 
 module Dry
   module Types
@@ -34,6 +35,10 @@ module Dry
               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
@@ -116,15 +121,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)
@@ -160,6 +181,15 @@ 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)

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api public
+    class Constructor < Nominal
+      module Wrapper
+        # @return [Object]
+        #
+        # @api private
+        def call_safe(input, &block)
+          fn.(input, type, &block)
+        end
+
+        # @return [Object]
+        #
+        # @api private
+        def call_unsafe(input)
+          fn.(input, type)
+        end
+
+        # @param [Object] input
+        # @param [#call,nil] block
+        #
+        # @return [Logic::Result, Types::Result]
+        # @return [Object] if block given and try fails
+        #
+        # @api public
+        def try(input, &block)
+          value = fn.(input, type)
+        rescue CoercionError => e
+          failure = failure(input, e)
+          block_given? ? yield(failure) : failure
+        else
+          type.try(value, &block)
+        end
+
+        # Define a constructor for the type
+        #
+        # @param [#call,nil] constructor
+        # @param [Hash] options
+        # @param [#call,nil] block
+        #
+        # @return [Constructor]
+        #
+        # @api public
+        define_method(:constructor, Builder.instance_method(:constructor))
+        alias_method :append, :constructor
+        alias_method :>>, :constructor
+
+        # Build a new constructor by prepending a block to the coercion function
+        #
+        # @param [#call, nil] new_fn
+        # @param [Hash] options
+        # @param [#call, nil] block
+        #
+        # @return [Constructor]
+        #
+        # @api public
+        def prepend(new_fn = nil, **options, &block)
+          prep_fn = Function[new_fn || block]
+
+          decorated =
+            if prep_fn.wrapper?
+              type.constructor(prep_fn, **options)
+            else
+              type.prepend(prep_fn, **options)
+            end
+
+          __new__(decorated)
+        end
+        alias_method :<<, :prepend
+
+        # @return [Constructor]
+        #
+        # @api public
+        def lax
+          # return self back because wrapping function
+          # can handle failed type check
+          self
+        end
+
+        private
+
+        # Replace underlying type
+        #
+        # @api private
+        def __new__(type)
+          self.class.new(type, *@__args__.drop(1), **@options)
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/container.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/container'
+require "dry/container"
 
 module Dry
   module Types

data/lib/dry/types/core.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/types/any'
+require "dry/types/any"
 
 module Dry
   module Types
@@ -83,17 +83,17 @@ module Dry
     end
 
     # 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('any', Any)
-    register('nominal.any', Any)
-    register('strict.any', Any)
+    register("nominal.bool", self["nominal.true"] | self["nominal.false"])
+    bool = self["strict.true"] | self["strict.false"]
+    register("strict.bool", bool)
+    register("bool", bool)
+
+    register("any", Any)
+    register("nominal.any", Any)
+    register("strict.any", Any)
   end
 end
 
-require 'dry/types/coercions'
-require 'dry/types/params'
-require 'dry/types/json'
+require "dry/types/coercions"
+require "dry/types/params"
+require "dry/types/json"