dry-types 0.15.0 → 1.5.1

data/lib/dry/types/lax.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "dry/core/deprecations"
+require "dry/types/decorator"
+
+module Dry
+  module Types
+    # Lax types rescue from type-related errors when constructors fail
+    #
+    # @api public
+    class Lax
+      include Type
+      include Decorator
+      include Builder
+      include Printable
+      include Dry::Equalizer(:type, inspect: false, immutable: true)
+
+      undef :options, :constructor, :<<, :>>, :prepend, :append
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api public
+      def call(input)
+        type.call_safe(input) { |output = input| output }
+      end
+      alias_method :[], :call
+      alias_method :call_safe, :call
+      alias_method :call_unsafe, :call
+
+      # @param [Object] input
+      # @param [#call,nil] block
+      #
+      # @yieldparam [Failure] failure
+      # @yieldreturn [Result]
+      #
+      # @return [Result,Logic::Result]
+      #
+      # @api public
+      def try(input, &block)
+        type.try(input, &block)
+      end
+
+      # @see Nominal#to_ast
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:lax, type.to_ast(meta: meta)]
+      end
+
+      # @return [Lax]
+      #
+      # @api public
+      def lax
+        self
+      end
+
+      private
+
+      # @param [Object, Dry::Types::Constructor] response
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def decorate?(response)
+        super || response.is_a?(type.constructor_type)
+      end
+    end
+
+    extend ::Dry::Core::Deprecations[:'dry-types']
+    Safe = Lax
+    deprecate_constant(:Safe)
+  end
+end

data/lib/dry/types/map.rb

@@ -1,96 +1,134 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
+    # Homogeneous mapping. It describes a hash with unknown keys that match a certain type.
+    #
+    # @example
+    #   type = Dry::Types['hash'].map(
+    #     Dry::Types['integer'].constrained(gteq: 1, lteq: 10),
+    #     Dry::Types['string']
+    #   )
+    #
+    #   type.(1 => 'right')
+    #   # => {1 => 'right'}
+    #
+    #   type.('1' => 'wrong')
+    #   # Dry::Types::MapError: "1" violates constraints (type?(Integer, "1") AND gteq?(1, "1") AND lteq?(10, "1") failed)
+    #
+    #   type.(11 => 'wrong')
+    #   # Dry::Types::MapError: 11 violates constraints (lteq?(10, 11) failed)
+    #
+    # @api public
     class Map < Nominal
-      def initialize(_primitive, key_type: Types['any'], value_type: Types['any'], meta: EMPTY_HASH)
+      def initialize(_primitive, key_type: Types["any"], value_type: Types["any"], meta: EMPTY_HASH)
         super(_primitive, key_type: key_type, value_type: value_type, meta: meta)
-        validate_options!
       end
 
       # @return [Type]
+      #
+      # @api public
       def key_type
         options[:key_type]
       end
 
       # @return [Type]
+      #
+      # @api public
       def value_type
         options[:value_type]
       end
 
       # @return [String]
+      #
+      # @api public
       def name
         "Map"
       end
 
       # @param [Hash] hash
+      #
       # @return [Hash]
-      def call(hash)
-        try(hash) do |failure|
-          raise MapError, failure.error.join("\n")
-        end.input
+      #
+      # @api private
+      def call_unsafe(hash)
+        try(hash) { |failure|
+          raise MapError, failure.error.message
+        }.input
       end
-      alias_method :[], :call
 
       # @param [Hash] hash
-      # @return [Boolean]
-      def valid?(hash)
-        coerce(hash).success?
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def call_safe(hash)
+        try(hash) { return yield }.input
       end
-      alias_method :===, :valid?
 
       # @param [Hash] hash
+      #
       # @return [Result]
+      #
+      # @api public
       def try(hash)
         result = coerce(hash)
         return result if result.success? || !block_given?
+
         yield(result)
       end
 
       # @param meta [Boolean] Whether to dump the meta to the AST
+      #
       # @return [Array] An AST representation
+      #
+      # @api public
       def to_ast(meta: true)
         [:map,
-         [key_type.to_ast(meta: true), value_type.to_ast(meta: true),
+         [key_type.to_ast(meta: true),
+          value_type.to_ast(meta: true),
           meta ? self.meta : EMPTY_HASH]]
       end
 
       # @return [Boolean]
+      #
+      # @api public
       def constrained?
         value_type.constrained?
       end
 
       private
 
+      # @api private
       def coerce(input)
-        return failure(
-          input, "#{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)
+          res_v = value_type.try(v)
 
-        input.each do |k,v|
-          res_k = options[:key_type].try(k)
-          res_v = options[:value_type].try(v)
           if res_k.failure?
-            failures << "input key #{k.inspect} is invalid: #{res_k.error}"
+            failures << res_k.error
           elsif output.key?(res_k.input)
-            failures << "duplicate coerced hash key #{res_k.input.inspect}"
+            failures << CoercionError.new("duplicate coerced hash key #{res_k.input.inspect}")
           elsif res_v.failure?
-            failures << "input value #{v.inspect} for key #{k.inspect} is invalid: #{res_v.error}"
+            failures << res_v.error
           else
             output[res_k.input] = res_v.input
           end
         end
 
-        return success(output) if failures.empty?
-
-        failure(input, failures)
-      end
-
-      def validate_options!
-        %i(key_type value_type).each do |opt|
-          type = send(opt)
-          next if type.is_a?(Type)
-          raise MapError, ":#{opt} must be a #{Type}, got: #{type.inspect}"
+        if failures.empty?
+          success(output)
+        else
+          failure(input, MultipleError.new(failures))
         end
       end
     end

data/lib/dry/types/meta.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Storage for meta-data
+    #
+    # @api public
+    module Meta
+      def initialize(*args, meta: EMPTY_HASH, **options)
+        super(*args, **options)
+        @meta = meta.freeze
+      end
+
+      # @param options [Hash] new_options
+      #
+      # @return [Type]
+      #
+      # @api public
+      def with(**options)
+        super(meta: @meta, **options)
+      end
+
+      # @overload meta
+      #   @return [Hash] metadata associated with type
+      #
+      # @overload meta(data)
+      #   @param [Hash] new metadata to merge into existing metadata
+      #   @return [Type] new type with added metadata
+      #
+      # @api public
+      def meta(data = Undefined)
+        if Undefined.equal?(data)
+          @meta
+        elsif data.empty?
+          self
+        else
+          with(meta: @meta.merge(data))
+        end
+      end
+
+      # Resets meta
+      #
+      # @return [Dry::Types::Type]
+      #
+      # @api public
+      def pristine
+        with(meta: EMPTY_HASH)
+      end
+    end
+  end
+end

data/lib/dry/types/module.rb

@@ -1,22 +1,27 @@
-require 'dry/core/deprecations'
-require 'dry/types/builder_methods'
+# frozen_string_literal: true
+
+require "dry/core/deprecations"
+require "dry/types/builder_methods"
 
 module Dry
   module Types
     # Export types registered in a container as module constants.
     # @example
     #   module Types
-    #     include Dry::Types.module(:strict, :coercible, :nominal, default: :strict)
+    #     include Dry::Types(:strict, :coercible, :nominal, default: :strict)
     #   end
-    #   # Types.constants
+    #
+    #   Types.constants
     #   # => [:Class, :Strict, :Symbol, :Integer, :Float, :String, :Array, :Hash,
     #   #     :Decimal, :Nil, :True, :False, :Bool, :Date, :Nominal, :DateTime, :Range,
     #   #     :Coercible, :Time]
+    #
+    # @api public
     class Module < ::Module
-      def initialize(registry, *args)
+      def initialize(registry, *args, **kwargs)
         @registry = registry
-        check_parameters(*args)
-        constants = type_constants(*args)
+        check_parameters(*args, **kwargs)
+        constants = type_constants(*args, **kwargs)
         define_constants(constants)
         extend(BuilderMethods)
 
@@ -64,7 +69,7 @@ module Dry
       def registry_tree
         @registry_tree ||= @registry.keys.each_with_object({}) { |key, tree|
           type = @registry[key]
-          *modules, const_name = key.split('.').map { |part|
+          *modules, const_name = key.split(".").map { |part|
             Inflector.camelize(part).to_sym
           }
           next if modules.empty?
@@ -82,14 +87,14 @@ module Dry
         referenced.concat(aliases.keys)
 
         known = @registry.keys.map { |k|
-          ns, *path = k.split('.')
+          ns, *path = k.split(".")
           ns.to_sym unless path.empty?
         }.compact.uniq
 
         (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

@@ -1,22 +1,35 @@
-require 'dry/core/deprecations'
-require 'dry/types/builder'
-require 'dry/types/result'
-require 'dry/types/options'
+# frozen_string_literal: true
+
+require "dry/core/deprecations"
+require "dry/core/equalizer"
+require "dry/types/builder"
+require "dry/types/result"
+require "dry/types/options"
+require "dry/types/meta"
 
 module Dry
   module Types
+    # Nominal types define a primitive class and do not apply any constructors or constraints
+    #
+    # Use these types for annotations and the base for building more complex types on top of them.
+    #
+    # @api public
     class Nominal
       include Type
       include Options
+      include Meta
       include Builder
       include Printable
-      include Dry::Equalizer(:primitive, :options, :meta, inspect: false)
+      include Dry::Equalizer(:primitive, :options, :meta, inspect: false, immutable: true)
 
       # @return [Class]
       attr_reader :primitive
 
       # @param [Class] primitive
+      #
       # @return [Type]
+      #
+      # @api private
       def self.[](primitive)
         if primitive == ::Array
           Types::Array
@@ -27,8 +40,12 @@ module Dry
         end
       end
 
+      ALWAYS = proc { true }
+
       # @param [Type,Class] primitive
       # @param [Hash] options
+      #
+      # @api private
       def initialize(primitive, **options)
         super
         @primitive = primitive
@@ -36,76 +53,150 @@ module Dry
       end
 
       # @return [String]
+      #
+      # @api public
       def name
         primitive.name
       end
 
       # @return [false]
+      #
+      # @api public
       def default?
         false
       end
 
       # @return [false]
+      #
+      # @api public
       def constrained?
         false
       end
 
       # @return [false]
+      #
+      # @api public
       def optional?
         false
       end
 
       # @param [BasicObject] input
+      #
+      # @return [BasicObject]
+      #
+      # @api private
+      def call_unsafe(input)
+        input
+      end
+
+      # @param [BasicObject] input
+      #
       # @return [BasicObject]
-      def call(input)
+      #
+      # @api private
+      def call_safe(input)
         input
       end
-      alias_method :[], :call
 
       # @param [Object] input
-      # @param [#call,nil] block
+      #
       # @yieldparam [Failure] failure
       # @yieldreturn [Result]
+      #
       # @return [Result,Logic::Result] when a block is not provided
       # @return [nil] otherwise
-      def try(input, &block)
-        if valid?(input)
-          success(input)
-        else
-          failure = failure(input, "#{input.inspect} must be an instance of #{primitive}")
-          block ? yield(failure) : failure
-        end
+      #
+      # @api public
+      def try(input)
+        success(input)
       end
 
       # @param (see Dry::Types::Success#initialize)
+      #
       # @return [Result::Success]
+      #
+      # @api public
       def success(input)
         Result::Success.new(input)
       end
 
       # @param (see Failure#initialize)
+      #
       # @return [Result::Failure]
+      #
+      # @api public
       def failure(input, error)
+        raise ArgumentError, "error must be a CoercionError" unless error.is_a?(CoercionError)
+
         Result::Failure.new(input, error)
       end
 
       # Checks whether value is of a #primitive class
+      #
       # @param [Object] value
+      #
       # @return [Boolean]
+      #
+      # @api public
       def primitive?(value)
         value.is_a?(primitive)
       end
-      alias_method :valid?, :primitive?
-      alias_method :===, :primitive?
+
+      # @api private
+      def coerce(input, &_block)
+        if primitive?(input)
+          input
+        elsif block_given?
+          yield
+        else
+          raise CoercionError, "#{input.inspect} must be an instance of #{primitive}"
+        end
+      end
+
+      # @api private
+      def try_coerce(input)
+        result = success(input)
+
+        coerce(input) do
+          result = failure(
+            input,
+            CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
+          )
+        end
+
+        if block_given?
+          yield(result)
+        else
+          result
+        end
+      end
 
       # Return AST representation of a type nominal
       #
-      # @api public
-      #
       # @return [Array]
+      #
+      # @api public
       def to_ast(meta: true)
         [:nominal, [primitive, meta ? self.meta : EMPTY_HASH]]
       end
+
+      # Return self. Nominal types are lax by definition
+      #
+      # @return [Nominal]
+      #
+      # @api public
+      def lax
+        self
+      end
+
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc
+        ALWAYS
+      end
     end
 
     extend Dry::Core::Deprecations[:'dry-types']
@@ -114,6 +205,6 @@ module Dry
   end
 end
 
-require 'dry/types/array'
-require 'dry/types/hash'
-require 'dry/types/map'
+require "dry/types/array"
+require "dry/types/hash"
+require "dry/types/map"

data/lib/dry/types/options.rb

@@ -1,42 +1,29 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
+    # Common API for types with options
+    #
+    # @api private
     module Options
       # @return [Hash]
       attr_reader :options
 
       # @see Nominal#initialize
-      def initialize(*args, meta: EMPTY_HASH, **options)
+      #
+      # @api private
+      def initialize(*args, **options)
         @__args__ = args.freeze
         @options = options.freeze
-        @meta = meta.freeze
       end
 
       # @param [Hash] new_options
+      #
       # @return [Type]
-      def with(**new_options)
-        self.class.new(*@__args__, **options, meta: @meta, **new_options)
-      end
-
-      # @overload meta
-      #   @return [Hash] metadata associated with type
       #
-      # @overload meta(data)
-      #   @param [Hash] new metadata to merge into existing metadata
-      #   @return [Type] new type with added metadata
-      def meta(data = nil)
-        if !data
-          @meta
-        elsif data.empty?
-          self
-        else
-          with(meta: @meta.merge(data))
-        end
-      end
-
-      # Resets meta
-      # @return [Dry::Types::Type]
-      def pristine
-        with(meta: EMPTY_HASH)
+      # @api private
+      def with(**new_options)
+        self.class.new(*@__args__, **options, **new_options)
       end
     end
   end