dry-types 0.13.2 → 1.5.1

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "dry/monads/result"
+
+module Dry
+  module Types
+    # Monad extension for Result
+    #
+    # @api public
+    class Result
+      include Dry::Monads::Result::Mixin
+
+      # Turn result into a monad
+      #
+      # This makes result objects work with dry-monads (or anything with a compatible interface)
+      #
+      # @return [Dry::Monads::Success,Dry::Monads::Failure]
+      #
+      # @api public
+      def to_monad
+        if success?
+          Success(input)
+        else
+          Failure([error, input])
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/fn_container.rb

@@ -1,7 +1,12 @@
-require 'dry/types/container'
+# frozen_string_literal: true
+
+require "dry/types/container"
 
 module Dry
   module Types
+    # Internal container for constructor functions used by the built-in types
+    #
+    # @api private
     class FnContainer
       # @api private
       def self.container

data/lib/dry/types/hash.rb

@@ -1,34 +1,44 @@
-require 'dry/types/hash/schema_builder'
+# frozen_string_literal: true
+
+require "dry/types/hash/constructor"
 
 module Dry
   module Types
-    class Hash < Definition
-      SCHEMA_BUILDER = SchemaBuilder.new.freeze
-
-      # @param [{Symbol => Definition}] type_map
-      # @param [Symbol] constructor
-      # @return [Schema]
-      def schema(type_map, constructor = nil)
-        member_types = transform_types(type_map)
-
-        if constructor.nil?
-          Schema.new(primitive, member_types: member_types, **options, meta: meta)
+    # Hash types can be used to define maps and schemas
+    #
+    # @api public
+    class Hash < Nominal
+      NOT_REQUIRED = {required: false}.freeze
+
+      # @overload schema(type_map, meta = EMPTY_HASH)
+      #   @param [{Symbol => Dry::Types::Nominal}] type_map
+      #   @param [Hash] meta
+      #   @return [Dry::Types::Schema]
+      #
+      # @overload schema(keys)
+      #   @param [Array<Dry::Types::Schema::Key>] key List of schema keys
+      #   @param [Hash] meta
+      #   @return [Dry::Types::Schema]
+      #
+      # @api public
+      def schema(keys_or_map, meta = EMPTY_HASH)
+        if keys_or_map.is_a?(::Array)
+          keys = keys_or_map
         else
-          SCHEMA_BUILDER.(
-            primitive,
-            **options,
-            member_types: member_types,
-            meta: meta,
-            hash_type: constructor
-          )
+          keys = build_keys(keys_or_map)
         end
+
+        Schema.new(primitive, keys: keys, **options, meta: self.meta.merge(meta))
       end
 
       # Build a map type
       #
       # @param [Type] key_type
       # @param [Type] value_type
+      #
       # @return [Map]
+      #
+      # @api public
       def map(key_type, value_type)
         Map.new(
           primitive,
@@ -38,81 +48,90 @@ module Dry
         )
       end
 
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def weak(type_map)
-        schema(type_map, :weak)
-      end
-
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def permissive(type_map)
-        schema(type_map, :permissive)
-      end
-
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def strict(type_map)
-        schema(type_map, :strict)
-      end
-
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def strict_with_defaults(type_map)
-        schema(type_map, :strict_with_defaults)
-      end
-
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def symbolized(type_map)
-        schema(type_map, :symbolized)
-      end
-
-      # Build a schema from an AST
       # @api private
-      # @param [{Symbol => Definition}] member_types
-      # @return [Schema]
-      def instantiate(member_types)
-        SCHEMA_BUILDER.instantiate(primitive, **options, member_types: member_types)
+      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"
       end
+      alias_method :permissive, :weak
+      alias_method :strict, :weak
+      alias_method :strict_with_defaults, :weak
+      alias_method :symbolized, :weak
 
       # Injects a type transformation function for building schemas
+      #
       # @param [#call,nil] proc
       # @param [#call,nil] block
+      #
       # @return [Hash]
+      #
+      # @api public
       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)
-        meta(type_transform_fn: handle)
+        with(type_transform_fn: handle)
+      end
+
+      # @api private
+      def constructor_type
+        ::Dry::Types::Hash::Constructor
+      end
+
+      # Whether the type transforms types of schemas created by {Dry::Types::Hash#schema}
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def transform_types?
+        !options[:type_transform_fn].nil?
+      end
+
+      # @param meta [Boolean] Whether to dump the meta to the AST
+      #
+      # @return [Array] An AST representation
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:hash, [options.slice(:type_transform_fn), meta ? self.meta : EMPTY_HASH]]
       end
 
       private
 
       # @api private
-      def transform_types(type_map)
-        type_fn = meta.fetch(:type_transform_fn, Schema::NO_TRANSFORM)
+      def build_keys(type_map)
+        type_fn = options.fetch(:type_transform_fn, Schema::NO_TRANSFORM)
         type_transform = Dry::Types::FnContainer[type_fn]
 
-        type_map.each_with_object({}) { |(name, type), result|
-          result[name] = type_transform.(
-            resolve_type(type),
-            name
-          )
-        }
+        type_map.map do |map_key, type|
+          name, options = key_name(map_key)
+          key = Schema::Key.new(resolve_type(type), name, **options)
+          type_transform.(key)
+        end
       end
 
       # @api private
       def resolve_type(type)
         case type
-        when String, Class then Types[type]
+        when Type then type
+        when ::Class, ::String then Types[type]
         else type
         end
       end
+
+      # @api private
+      def key_name(key)
+        if key.to_s.end_with?("?")
+          [key.to_s.chop.to_sym, NOT_REQUIRED]
+        else
+          [key, EMPTY_HASH]
+        end
+      end
     end
   end
 end
+
+require "dry/types/schema/key"
+require "dry/types/schema"

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dry/types/constructor"
+
+module Dry
+  module Types
+    # Hash type exposes additional APIs for working with schema hashes
+    #
+    # @api public
+    class Hash < Nominal
+      class Constructor < ::Dry::Types::Constructor
+        # @api private
+        def constructor_type
+          ::Dry::Types::Hash::Constructor
+        end
+
+        # @return [Lax]
+        #
+        # @api public
+        def lax
+          type.lax.constructor(fn, meta: meta)
+        end
+
+        # @see Dry::Types::Array#of
+        #
+        # @api public
+        def schema(*args)
+          type.schema(*args).constructor(fn, meta: meta)
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/inflector.rb

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

data/lib/dry/types/json.rb

@@ -1,33 +1,35 @@
-require 'dry/types/coercions/json'
+# frozen_string_literal: true
+
+require "dry/types/coercions/json"
 
 module Dry
   module Types
-    register('json.nil') do
-      self['nil'].constructor(Coercions::JSON.method(:to_nil))
+    register("json.nil") do
+      self["nominal.nil"].constructor(Coercions::JSON.method(:to_nil))
     end
 
-    register('json.date') do
-      self['date'].constructor(Coercions::JSON.method(:to_date))
+    register("json.date") do
+      self["nominal.date"].constructor(Coercions::JSON.method(:to_date))
     end
 
-    register('json.date_time') do
-      self['date_time'].constructor(Coercions::JSON.method(:to_date_time))
+    register("json.date_time") do
+      self["nominal.date_time"].constructor(Coercions::JSON.method(:to_date_time))
     end
 
-    register('json.time') do
-      self['time'].constructor(Coercions::JSON.method(:to_time))
+    register("json.time") do
+      self["nominal.time"].constructor(Coercions::JSON.method(:to_time))
     end
 
-    register('json.decimal') do
-      self['decimal'].constructor(Coercions::JSON.method(:to_decimal))
+    register("json.decimal") do
+      self["nominal.decimal"].constructor(Coercions::JSON.method(:to_decimal))
     end
 
-    register('json.array') do
-      self['array'].safe
+    register("json.symbol") do
+      self["nominal.symbol"].constructor(Coercions::JSON.method(:to_symbol))
     end
 
-    register('json.hash') do
-      self['hash'].safe
-    end
+    register("json.array") { self["array"] }
+
+    register("json.hash") { self["hash"] }
   end
 end

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,91 +1,134 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
-    class Map < Definition
-      def initialize(_primitive, key_type: Types['any'], value_type: Types['any'], meta: EMPTY_HASH)
+    # 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)
         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