dry-types 0.12.3 → 0.14.1

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

@@ -12,19 +12,32 @@ module Dry
 
       # @param [Dry::Monads::Maybe, Object] input
       # @return [Dry::Monads::Maybe]
-      def call(input)
-        input.is_a?(Dry::Monads::Maybe) ? input : Maybe(type[input])
+      def call(input = Undefined)
+        case input
+        when Dry::Monads::Maybe
+          input
+        when Undefined
+          None()
+        else
+          Maybe(type[input])
+        end
       end
       alias_method :[], :call
 
       # @param [Object] input
       # @return [Result::Success]
-      def try(input)
-        Result::Success.new(Maybe(type[input]))
+      def try(input = Undefined)
+        res = if input.equal?(Undefined)
+                None()
+              else
+                Maybe(type[input])
+              end
+
+        Result::Success.new(res)
       end
 
       # @return [true]
-      def maybe?
+      def default?
         true
       end
 
@@ -47,29 +60,6 @@ module Dry
       end
     end
 
-    class Hash
-      module MaybeTypes
-        # @param [Hash] result
-        # @param [Symbol] key
-        # @param [Definition] type
-        def resolve_missing_value(result, key, type)
-          if type.respond_to?(:maybe?) && type.maybe?
-            result[key] = type[nil]
-          else
-            super
-          end
-        end
-      end
-
-      class StrictWithDefaults < Strict
-        include MaybeTypes
-      end
-
-      class Schema < Hash
-        include MaybeTypes
-      end
-    end
-
     # Register non-coercible maybe types
     NON_NIL.each_key do |name|
       register("maybe.strict.#{name}", self["strict.#{name}"].maybe)

data/lib/dry/types/fn_container.rb

@@ -9,18 +9,19 @@ module Dry
       end
 
       # @api private
-      def self.register(function)
-        register_function_name = register_name(function)
-        container.register(register_function_name, function) unless container.key?(register_function_name)
-        register_function_name
+      def self.register(function = Dry::Core::Constants::Undefined, &block)
+        fn = Dry::Core::Constants::Undefined.default(function, block)
+        fn_name = register_name(fn)
+        container.register(fn_name, fn) unless container.key?(fn_name)
+        fn_name
       end
 
       # @api private
-      def self.[](function_name)
-        if container.key?(function_name)
-          container[function_name]
+      def self.[](fn_name)
+        if container.key?(fn_name)
+          container[fn_name]
         else
-          function_name
+          fn_name
         end
       end
 

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

@@ -1,3 +1,5 @@
+require 'dry/types/fn_container'
+
 module Dry
   module Types
     class Hash < Definition
@@ -10,14 +12,27 @@ module Dry
       # @see Dry::Types::Default#evaluate
       # @see Dry::Types::Default::Callable#evaluate
       class Schema < Hash
+        NO_TRANSFORM = Dry::Types::FnContainer.register { |x| x }
+        SYMBOLIZE_KEY = Dry::Types::FnContainer.register(:to_sym.to_proc)
+
         # @return [Hash{Symbol => Definition}]
         attr_reader :member_types
 
+        # @return [#call]
+        attr_reader :transform_key
+
         # @param [Class] _primitive
         # @param [Hash] options
         # @option options [Hash{Symbol => Definition}] :member_types
-        def initialize(_primitive, options)
+        # @option options [String] :key_transform_fn
+        def initialize(_primitive, **options)
           @member_types = options.fetch(:member_types)
+
+          meta = options[:meta] || EMPTY_HASH
+          key_fn = meta.fetch(:key_transform_fn, NO_TRANSFORM)
+
+          @transform_key = Dry::Types::FnContainer[key_fn]
+
           super
         end
 
@@ -29,40 +44,46 @@ module Dry
         alias_method :[], :call
 
         # @param [Hash] hash
-        # @param [#call,nil] block
         # @yieldparam [Failure] failure
         # @yieldreturn [Result]
         # @return [Logic::Result]
         # @return [Object] if coercion fails and a block is given
-        def try(hash, &block)
-          success = true
-          output  = {}
+        def try(hash)
+          if hash.is_a?(::Hash)
+            success = true
+            output  = {}
 
-          begin
-            result = try_coerce(hash) do |key, member_result|
-              success &&= member_result.success?
-              output[key] = member_result.input
+            begin
+              result = try_coerce(hash) do |key, member_result|
+                success &&= member_result.success?
+                output[key] = member_result.input
 
-              member_result
+                member_result
+              end
+            rescue ConstraintError, UnknownKeysError, SchemaError, MissingKeyError => e
+              success = false
+              result = e
             end
-          rescue ConstraintError, UnknownKeysError, SchemaError => e
+          else
             success = false
-            result = e
+            output = hash
+            result = "#{hash} must be a hash"
           end
 
           if success
             success(output)
           else
             failure = failure(output, result)
-            block ? yield(failure) : failure
+            block_given? ? yield(failure) : failure
           end
         end
 
+        # @param meta [Boolean] Whether to dump the meta to the AST
+        # @return [Array] An AST representation
         def to_ast(meta: true)
           [
-            :hash,
+            :hash_schema,
             [
-              hash_type,
               member_types.map { |name, member| [:member, [name, member.to_ast(meta: meta)]] },
               meta ? self.meta : EMPTY_HASH
             ]
@@ -77,204 +98,102 @@ module Dry
         end
         alias_method :===, :valid?
 
-        private
-
-        def hash_type
-          :schema
+        # Whether the schema rejects unknown keys
+        # @return [Boolean]
+        def strict?
+          meta.fetch(:strict, false)
         end
 
-        # @param [Hash] hash
-        # @return [Hash{Symbol => Object}]
-        def try_coerce(hash)
-          resolve(hash) do |type, key, value|
-            yield(key, type.try(value))
-          end
+        # Make the schema intolerant to unknown keys
+        # @return [Schema]
+        def strict
+          meta(strict: true)
         end
 
-        # @param [Hash] hash
-        # @return [Hash{Symbol => Object}]
-        def coerce(hash)
-          resolve(hash) do |type, key, value|
-            begin
-              type.call(value)
-            rescue ConstraintError => e
-              raise SchemaError.new(key, value, e.result)
-            end
-          end
-        end
-
-        # @param [Hash] hash
-        # @return [Hash{Symbol => Object}]
-        def resolve(hash)
-          result = {}
-          member_types.each do |key, type|
-            if hash.key?(key)
-              result[key] = yield(type, key, hash[key])
-            else
-              resolve_missing_value(result, key, type)
-            end
-          end
-          result
-        end
+        # Injects a key transformation function
+        # @param [#call,nil] proc
+        # @param [#call,nil] block
+        # @return [Schema]
+        def with_key_transform(proc = nil, &block)
+          fn = proc || block
 
-        # @param [Hash] result
-        # @param [Symbol] key
-        # @param [Type] type
-        # @return [Object]
-        # @see Dry::Types::Default#evaluate
-        # @see Dry::Types::Default::Callable#evaluate
-        def resolve_missing_value(result, key, type)
-          if type.default?
-            result[key] = type.evaluate
-          else
-            super
+          if fn.nil?
+            raise ArgumentError, "a block or callable argument is required"
           end
-        end
-      end
-
-      # Permissive schema raises a {MissingKeyError} if the given key is missing
-      # in provided hash.
-      class Permissive < Schema
-        private
 
-        def hash_type
-          :permissive
+          handle = Dry::Types::FnContainer.register(fn)
+          meta(key_transform_fn: handle)
         end
 
-        # @param [Symbol] key
-        # @raise [MissingKeyError] when key is missing in given input
-        def resolve_missing_value(_, key, _)
-          raise MissingKeyError, key
+        # @param [{Symbol => Definition}] type_map
+        # @return [Schema]
+        def schema(type_map)
+          member_types = self.member_types.merge(transform_types(type_map))
+          Schema.new(primitive, **options, member_types: member_types, meta: meta)
         end
-      end
 
-      # Strict hash will raise errors when keys are missing or value types are incorrect.
-      # Strict schema raises a {UnknownKeysError} if there are any unexpected
-      # keys in given hash, and raises a {MissingKeyError} if any key is missing
-      # in it.
-      # @example
-      #   hash = Types::Hash.strict(name: Types::String, age: Types::Coercible::Int)
-      #   hash[email: 'jane@doe.org', name: 'Jane', age: 21]
-      #     # => Dry::Types::SchemaKeyError: :email is missing in Hash input
-      class Strict < Permissive
         private
 
-        def hash_type
-          :strict
-        end
-
-        # @param [Hash] hash
-        # @return [Hash{Symbol => Object}]
-        # @raise [UnknownKeysError]
-        #   if there any unexpected key in given hash
-        # @raise [MissingKeyError]
-        #   if a required key is not present
-        # @raise [SchemaError]
-        #   if a value is the wrong type
         def resolve(hash)
-          unexpected = hash.keys - member_types.keys
-          raise UnknownKeysError.new(*unexpected) unless unexpected.empty?
+          result = {}
 
-          super do |member_type, key, value|
-            type = member_type.default? ? member_type.type : member_type
+          hash.each do |key, value|
+            k = transform_key.(key)
 
-            yield(type, key, value)
+            if member_types.key?(k)
+              result[k] = yield(member_types[k], k, value)
+            elsif strict?
+              raise UnknownKeysError.new(*unexpected_keys(hash.keys))
+            end
           end
-        end
-      end
-
-      # {StrictWithDefaults} checks that there are no extra keys
-      # (raises {UnknownKeysError} otherwise) and there a no missing keys
-      # without default values given (raises {MissingKeyError} otherwise).
-      # @see Default#evaluate
-      # @see Default::Callable#evaluate
-      class StrictWithDefaults < Strict
-        private
 
-        def hash_type
-          :strict_with_defaults
-        end
-
-        # @param [Hash] result
-        # @param [Symbol] key
-        # @param [Type] type
-        # @return [Object]
-        # @see Dry::Types::Default#evaluate
-        # @see Dry::Types::Default::Callable#evaluate
-        def resolve_missing_value(result, key, type)
-          if type.default?
-            result[key] = type.evaluate
-          else
-            super
+          if result.size < member_types.size
+            resolve_missing_keys(result, &Proc.new)
           end
-        end
-      end
-
-      # Weak schema provides safe types for every type given in schema hash
-      # @see Safe
-      class Weak < Schema
-        # @param [Class] primitive
-        # @param [Hash] options
-        # @see #initialize
-        def self.new(primitive, options)
-          member_types = options.
-            fetch(:member_types).
-            each_with_object({}) { |(k, t), res| res[k] = t.safe }
 
-          super(primitive, options.merge(member_types: member_types))
+          result
         end
 
-        # @param [Object] value
-        # @param [#call, nil] block
-        # @yieldparam [Failure] failure
-        # @yieldreturn [Result]
-        # @return [Object] if block given
-        # @return [Result,Logic::Result] otherwise
-        def try(value, &block)
-          if value.is_a?(::Hash)
-            super
-          else
-            result = failure(value, "#{value} must be a hash")
-            block ? yield(result) : result
+        def resolve_missing_keys(result)
+          member_types.each do |k, type|
+            next if result.key?(k)
+
+            if type.default?
+              result[k] = yield(type, k, Undefined)
+            elsif !type.meta[:omittable]
+              raise MissingKeyError, k
+            end
           end
         end
 
-        private
-
-        def hash_type
-          :weak
+        # @param keys [Array<Symbol>]
+        # @return [Array<Symbol>]
+        def unexpected_keys(keys)
+          keys.map(&transform_key) - member_types.keys
         end
-      end
-
-      # {Symbolized} hash will turn string key names into symbols.
-      class Symbolized < Weak
-        private
 
-        def hash_type
-          :symbolized
+        # @param [Hash] hash
+        # @return [Hash{Symbol => Object}]
+        def try_coerce(hash)
+          resolve(hash) do |type, key, value|
+            yield(key, type.try(value))
+          end
         end
 
-        def resolve(hash)
-          result = {}
-          member_types.each do |key, type|
-            keyname =
-              if hash.key?(key)
-                key
-              elsif hash.key?(string_key = key.to_s)
-                string_key
-              end
-
-            if keyname
-              result[key] = yield(type, key, hash[keyname])
-            else
-              resolve_missing_value(result, key, type)
+        # @param [Hash] hash
+        # @return [Hash{Symbol => Object}]
+        def coerce(hash)
+          resolve(hash) do |type, key, value|
+            begin
+              type.call(value)
+            rescue ConstraintError => e
+              raise SchemaError.new(key, value, e.result)
+            rescue TypeError, ArgumentError => e
+              raise SchemaError.new(key, value, e.message)
             end
           end
-          result
         end
       end
-
-      private_constant(*constants(false))
     end
   end
 end

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

@@ -0,0 +1,75 @@
+require 'dry/types/hash/schema'
+require 'dry/types/fn_container'
+
+module Dry
+  module Types
+    class Hash < Definition
+      # A bulder for legacy schemas
+      # @api private
+      class SchemaBuilder
+        NIL_TO_UNDEFINED = -> v { v.nil? ? Undefined : v }
+        OMITTABLE_KEYS = %i(schema weak symbolized).freeze
+        STRICT = %i(strict strict_with_defaults).freeze
+
+        # @param primitive [Type]
+        # @option options [Hash{Symbol => Definition}] :member_types
+        # @option options [Symbol] :hash_type
+        def call(primitive, **options)
+          hash_type = options.fetch(:hash_type)
+          member_types = {}
+
+          options.fetch(:member_types).each do |k, t|
+            member_types[k] = build_type(hash_type, t)
+          end
+
+          instantiate(primitive, **options, member_types: member_types)
+        end
+
+        def instantiate(primitive, hash_type: :base, meta: EMPTY_HASH, **options)
+          meta = meta.dup
+
+          meta[:strict] = true if strict?(hash_type)
+          meta[:key_transform_fn] = Schema::SYMBOLIZE_KEY if hash_type == :symbolized
+
+          Schema.new(primitive, **options, meta: meta)
+        end
+
+        private
+
+        def omittable?(constructor)
+          OMITTABLE_KEYS.include?(constructor)
+        end
+
+        def strict?(constructor)
+          STRICT.include?(constructor)
+        end
+
+        def build_type(constructor, type)
+          type = safe(constructor, type)
+          type = default(constructor, type) if type.default?
+          type = type.meta(omittable: true) if omittable?(constructor)
+          type
+        end
+
+        def safe(constructor, type)
+          if constructor == :weak || constructor == :symbolized
+            type.safe
+          else
+            type
+          end
+        end
+
+        def default(constructor, type)
+          case constructor
+          when :strict_with_defaults
+            type
+          when :strict
+            type.type
+          else
+            type.constructor(NIL_TO_UNDEFINED)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/hash.rb

@@ -1,62 +1,117 @@
-require 'dry/types/hash/schema'
+require 'dry/types/hash/schema_builder'
 
 module Dry
   module Types
     class Hash < Definition
+      SCHEMA_BUILDER = SchemaBuilder.new.freeze
+
       # @param [{Symbol => Definition}] type_map
-      # @param [Class] klass
-      #   {Schema} or one of its subclasses ({Weak}, {Permissive}, {Strict},
-      #   {StrictWithDefaults}, {Symbolized})
+      # @param [Symbol] constructor
       # @return [Schema]
-      def schema(type_map, klass = Schema)
-        member_types = type_map.each_with_object({}) { |(name, type), result|
-          result[name] =
-            case type
-            when String, Class then Types[type]
-            else type
-            end
-        }
+      def schema(type_map, constructor = nil)
+        member_types = transform_types(type_map)
 
-        klass.new(primitive, options.merge(member_types: member_types, meta: meta))
+        if constructor.nil?
+          Schema.new(primitive, member_types: member_types, **options, meta: meta)
+        else
+          SCHEMA_BUILDER.(
+            primitive,
+            **options,
+            member_types: member_types,
+            meta: meta,
+            hash_type: constructor
+          )
+        end
+      end
+
+      # Build a map type
+      #
+      # @param [Type] key_type
+      # @param [Type] value_type
+      # @return [Map]
+      def map(key_type, value_type)
+        Map.new(
+          primitive,
+          key_type: resolve_type(key_type),
+          value_type: resolve_type(value_type),
+          meta: meta
+        )
       end
 
       # @param [{Symbol => Definition}] type_map
-      # @return [Weak]
+      # @return [Schema]
       def weak(type_map)
-        schema(type_map, Weak)
+        schema(type_map, :weak)
       end
 
       # @param [{Symbol => Definition}] type_map
-      # @return [Permissive]
+      # @return [Schema]
       def permissive(type_map)
-        schema(type_map, Permissive)
+        schema(type_map, :permissive)
       end
 
       # @param [{Symbol => Definition}] type_map
-      # @return [Strict]
+      # @return [Schema]
       def strict(type_map)
-        schema(type_map, Strict)
+        schema(type_map, :strict)
       end
 
       # @param [{Symbol => Definition}] type_map
-      # @return [StrictWithDefaults]
+      # @return [Schema]
       def strict_with_defaults(type_map)
-        schema(type_map, StrictWithDefaults)
+        schema(type_map, :strict_with_defaults)
       end
 
       # @param [{Symbol => Definition}] type_map
-      # @return [Symbolized]
+      # @return [Schema]
       def symbolized(type_map)
-        schema(type_map, Symbolized)
+        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)
+      end
+
+      # Injects a type transformation function for building schemas
+      # @param [#call,nil] proc
+      # @param [#call,nil] block
+      # @return [Hash]
+      def with_type_transform(proc = nil, &block)
+        fn = proc || block
+
+        if fn.nil?
+          raise ArgumentError, "a block or callable argument is required"
+        end
+
+        handle = Dry::Types::FnContainer.register(fn)
+        meta(type_transform_fn: handle)
       end
 
       private
 
-      # @param [Hash] _result
-      # @param [Symbol] _key
-      # @param [Type] _type
-      def resolve_missing_value(_result, _key, _type)
-        # noop
+      # @api private
+      def transform_types(type_map)
+        type_fn = meta.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
+          )
+        }
+      end
+
+      # @api private
+      def resolve_type(type)
+        case type
+        when String, Class then Types[type]
+        else type
+        end
       end
     end
   end

data/lib/dry/types/inflector.rb

@@ -0,0 +1,7 @@
+require 'dry/inflector'
+
+module Dry
+  module Types
+    Inflector = Dry::Inflector.new
+  end
+end