dry-types 0.13.2 → 1.5.1

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

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "concurrent/map"
+
+module Dry
+  module Types
+    class Constructor < Nominal
+      # Function is used internally by Constructor types
+      #
+      # @api private
+      class Function
+        # Wrapper for unsafe coercion functions
+        #
+        # @api private
+        class Safe < Function
+          def call(input, &block)
+            @fn.(input, &block)
+          rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
+            CoercionError.handle(e, &block)
+          end
+        end
+
+        # Coercion via a method call on a known object
+        #
+        # @api private
+        class MethodCall < Function
+          @cache = ::Concurrent::Map.new
+
+          # Choose or build the base class
+          #
+          # @return [Function]
+          def self.call_class(method, public, safe)
+            @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
+              else
+                PrivateSafeCall
+              end
+            end
+          end
+
+          # Coercion with a publicly accessible method call
+          #
+          # @api private
+          class PublicCall < MethodCall
+            @interfaces = ::Concurrent::Map.new
+
+            # Choose or build the interface
+            #
+            # @return [::Module]
+            def self.call_interface(method, safe)
+              @interfaces.fetch_or_store([method, safe]) do
+                ::Module.new do
+                  if safe
+                    module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+                      def call(input, &block)
+                        @target.#{method}(input, &block)
+                      end
+                    RUBY
+                  else
+                    module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+                      def call(input, &block)
+                        @target.#{method}(input)
+                      rescue ::NoMethodError, ::TypeError, ::ArgumentError => error
+                        CoercionError.handle(error, &block)
+                      end
+                    RUBY
+                  end
+                end
+              end
+            end
+          end
+
+          # Coercion via a private method call
+          #
+          # @api private
+          class PrivateCall < MethodCall
+            def call(input, &block)
+              @target.send(@name, input, &block)
+            end
+          end
+
+          # Coercion via an unsafe private method call
+          #
+          # @api private
+          class PrivateSafeCall < PrivateCall
+            def call(input, &block)
+              @target.send(@name, input)
+            rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
+              CoercionError.handle(e, &block)
+            end
+          end
+
+          # @api private
+          #
+          # @return [MethodCall]
+          def self.[](fn, safe)
+            public = fn.receiver.respond_to?(fn.name)
+            MethodCall.call_class(fn.name, public, safe).new(fn)
+          end
+
+          attr_reader :target, :name
+
+          def initialize(fn)
+            super
+            @target = fn.receiver
+            @name = fn.name
+          end
+
+          def to_ast
+            [:method, target, name]
+          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?
+
+          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)
+            new(fn)
+          else
+            Safe.new(fn)
+          end
+        end
+
+        # @return [Boolean]
+        def self.yields_block?(fn)
+          *, (last_arg,) =
+            if fn.respond_to?(:parameters)
+              fn.parameters
+            else
+              fn.method(:call).parameters
+            end
+
+          last_arg.equal?(:block)
+        end
+
+        include ::Dry::Equalizer(:fn, immutable: true)
+
+        attr_reader :fn
+
+        def initialize(fn)
+          @fn = fn
+        end
+
+        # @return [Object]
+        def call(input, &block)
+          @fn.(input, &block)
+        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, FnContainer.register(fn)]
+          else
+            [:callable, fn]
+          end
+        end
+
+        # @return [Function]
+        def >>(other)
+          f = Function[other]
+          Function[-> x, &b { f.(self.(x, &b), &b) }]
+        end
+
+        # @return [Function]
+        def <<(other)
+          f = Function[other]
+          Function[-> x, &b { self.(f.(x, &b), &b) }]
+        end
+      end
+    end
+  end
+end

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,5 +1,12 @@
+# frozen_string_literal: true
+
+require "dry/container"
+
 module Dry
   module Types
+    # Internal container for the built-in types
+    #
+    # @api private
     class Container
       include Dry::Container::Mixin
     end

data/lib/dry/types/core.rb

@@ -1,8 +1,11 @@
-require 'dry/types/any'
+# frozen_string_literal: true
+
+require "dry/types/any"
 
 module Dry
   module Types
-    COERCIBLE = {
+    # Primitives with {Kernel} coercion methods
+    KERNEL_COERCIBLE = {
       string: String,
       integer: Integer,
       float: Float,
@@ -11,9 +14,19 @@ module Dry
       hash: ::Hash
     }.freeze
 
+    # 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,
@@ -23,44 +36,64 @@ module Dry
       range: Range
     }.freeze
 
-    ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).freeze
+    # All built-in primitives
+    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
 
-    # Register built-in types that are non-coercible through kernel methods
+    # Register generic types for {ALL_PRIMITIVES}
     ALL_PRIMITIVES.each do |name, primitive|
-      register(name.to_s, Definition[primitive].new(primitive))
+      type = Nominal[primitive].new(primitive)
+      register("nominal.#{name}", type)
     end
 
-    # Register strict built-in types that are non-coercible through kernel methods
+    # Register strict types for {ALL_PRIMITIVES}
     ALL_PRIMITIVES.each do |name, primitive|
-      register("strict.#{name}", self[name.to_s].constrained(type: primitive))
+      type = self["nominal.#{name}"].constrained(type: primitive)
+      register(name.to_s, type)
+      register("strict.#{name}", type)
+    end
+
+    # Register {KERNEL_COERCIBLE} types
+    KERNEL_COERCIBLE.each do |name, primitive|
+      register("coercible.#{name}", self["nominal.#{name}"].constructor(Kernel.method(primitive.name)))
     end
 
-    # Register built-in primitive types with kernel coercion methods
-    COERCIBLE.each do |name, primitive|
-      register("coercible.#{name}", self[name.to_s].constructor(Kernel.method(primitive.name)))
+    # Register {METHOD_COERCIBLE} types
+    METHOD_COERCIBLE.each_key do |name|
+      register(
+        "coercible.#{name}", self["nominal.#{name}"].constructor(&METHOD_COERCIBLE_METHODS[name])
+      )
     end
 
-    # Register non-coercible optional types
+    # Register optional strict {NON_NIL} types
     NON_NIL.each_key do |name|
-      register("optional.strict.#{name}", self["strict.#{name}"].optional)
+      type = self[name.to_s].optional
+      register("optional.strict.#{name}", type)
+      register("optional.#{name}", type)
     end
 
-    # Register coercible optional types
+    # Register optional {COERCIBLE} types
     COERCIBLE.each_key do |name|
       register("optional.coercible.#{name}", self["coercible.#{name}"].optional)
     end
 
-    # Register :bool since it's common and not a built-in Ruby type :(
-    register("bool", self["true"] | self["false"])
-    register("strict.bool", self["strict.true"] | self["strict.false"])
+    # 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("object", self['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"

data/lib/dry/types/decorator.rb

@@ -1,7 +1,12 @@
-require 'dry/types/options'
+# frozen_string_literal: true
+
+require "dry/types/options"
 
 module Dry
   module Types
+    # Common API for types
+    #
+    # @api public
     module Decorator
       include Options
 
@@ -9,63 +14,76 @@ module Dry
       attr_reader :type
 
       # @param [Type] type
-      def initialize(type, *)
+      def initialize(type, *, **)
         super
         @type = type
       end
 
       # @param [Object] input
       # @param [#call, nil] block
+      #
       # @return [Result,Logic::Result]
       # @return [Object] if block given and try fails
+      #
+      # @api public
       def try(input, &block)
         type.try(input, &block)
       end
 
-      # @param [Object] value
-      # @return [Boolean]
-      def valid?(value)
-        type.valid?(value)
-      end
-      alias_method :===, :valid?
-
       # @return [Boolean]
+      #
+      # @api public
       def default?
         type.default?
       end
 
       # @return [Boolean]
+      #
+      # @api public
       def constrained?
         type.constrained?
       end
 
-      # @return [Sum]
-      def optional
-        Types['strict.nil'] | self
-      end
-
       # @param [Symbol] meth
       # @param [Boolean] include_private
+      #
       # @return [Boolean]
+      #
+      # @api public
       def respond_to_missing?(meth, include_private = false)
         super || type.respond_to?(meth)
       end
 
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc
+        proc { |value| self.(value) }
+      end
+
       private
 
       # @param [Object] response
+      #
       # @return [Boolean]
+      #
+      # @api private
       def decorate?(response)
-        response.kind_of?(type.class)
+        response.is_a?(type.class)
       end
 
       # Delegates missing methods to {#type}
+      #
       # @param [Symbol] meth
       # @param [Array] args
       # @param [#call, nil] block
+      #
+      # @api private
       def method_missing(meth, *args, &block)
         if type.respond_to?(meth)
-          response = type.__send__(meth, *args, &block)
+          response = type.public_send(meth, *args, &block)
 
           if decorate?(response)
             __new__(response)
@@ -76,10 +94,13 @@ module Dry
           super
         end
       end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
       # Replace underlying type
+      #
+      # @api private
       def __new__(type)
-        self.class.new(type, options)
+        self.class.new(type, *@__args__.drop(1), **@options)
       end
     end
   end