dry-types 0.12.3 → 0.13.0

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
+        # @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 => 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/inflector.rb

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

data/lib/dry/types/map.rb

@@ -0,0 +1,93 @@
+module Dry
+  module Types
+    class Map < Definition
+      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]
+      def key_type
+        options[:key_type]
+      end
+
+      # @return [Type]
+      def value_type
+        options[:value_type]
+      end
+
+      # @return [String]
+      def name
+        "Map"
+      end
+
+      # @param [Hash] hash
+      # @return [Hash]
+      def call(hash)
+        try(hash) do |failure|
+          raise MapError, failure.error.join("\n")
+        end.input
+      end
+      alias_method :[], :call
+
+      # @param [Hash] hash
+      # @return [Boolean]
+      def valid?(hash)
+        coerce(hash).success?
+      end
+      alias_method :===, :valid?
+
+      # @param [Hash] hash
+      # @return [Result]
+      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
+      def to_ast(meta: true)
+        [:map,
+         [key_type.to_ast(meta: true), value_type.to_ast(meta: true),
+          meta ? self.meta : EMPTY_HASH]]
+      end
+
+      private
+
+      def coerce(input)
+        return failure(
+          input, "#{input.inspect} must be an instance of #{primitive}"
+        ) unless primitive?(input)
+
+        output, failures = {}, []
+
+        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}"
+          elsif output.key?(res_k.input)
+            failures << "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}"
+          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}"
+        end
+      end
+    end
+  end
+end