dry-types 0.14.1 → 1.5.1

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

@@ -1,199 +0,0 @@
-require 'dry/types/fn_container'
-
-module Dry
-  module Types
-    class Hash < Definition
-      # The built-in Hash type has constructors that you can use to define
-      # hashes with explicit schemas and coercible values using the built-in types.
-      #
-      # Basic {Schema} evaluates default values for keys missing in input hash
-      # (see {Schema#resolve_missing_value})
-      #
-      # @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
-
-        # @param [Hash] hash
-        # @return [Hash{Symbol => Object}]
-        def call(hash)
-          coerce(hash)
-        end
-        alias_method :[], :call
-
-        # @param [Hash] hash
-        # @yieldparam [Failure] failure
-        # @yieldreturn [Result]
-        # @return [Logic::Result]
-        # @return [Object] if coercion fails and a block is given
-        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
-
-                member_result
-              end
-            rescue ConstraintError, UnknownKeysError, SchemaError, MissingKeyError => e
-              success = false
-              result = e
-            end
-          else
-            success = false
-            output = hash
-            result = "#{hash} must be a hash"
-          end
-
-          if success
-            success(output)
-          else
-            failure = failure(output, result)
-            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_schema,
-            [
-              member_types.map { |name, member| [:member, [name, member.to_ast(meta: meta)]] },
-              meta ? self.meta : EMPTY_HASH
-            ]
-          ]
-        end
-
-        # @param [Hash] hash
-        # @return [Boolean]
-        def valid?(hash)
-          result = try(hash)
-          result.success?
-        end
-        alias_method :===, :valid?
-
-        # Whether the schema rejects unknown keys
-        # @return [Boolean]
-        def strict?
-          meta.fetch(:strict, false)
-        end
-
-        # Make the schema intolerant to unknown keys
-        # @return [Schema]
-        def strict
-          meta(strict: true)
-        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
-
-          if fn.nil?
-            raise ArgumentError, "a block or callable argument is required"
-          end
-
-          handle = Dry::Types::FnContainer.register(fn)
-          meta(key_transform_fn: handle)
-        end
-
-        # @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
-
-        private
-
-        def resolve(hash)
-          result = {}
-
-          hash.each do |key, value|
-            k = transform_key.(key)
-
-            if member_types.key?(k)
-              result[k] = yield(member_types[k], k, value)
-            elsif strict?
-              raise UnknownKeysError.new(*unexpected_keys(hash.keys))
-            end
-          end
-
-          if result.size < member_types.size
-            resolve_missing_keys(result, &Proc.new)
-          end
-
-          result
-        end
-
-        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
-
-        # @param keys [Array<Symbol>]
-        # @return [Array<Symbol>]
-        def unexpected_keys(keys)
-          keys.map(&transform_key) - member_types.keys
-        end
-
-        # @param [Hash] hash
-        # @return [Hash{Symbol => Object}]
-        def try_coerce(hash)
-          resolve(hash) do |type, key, value|
-            yield(key, type.try(value))
-          end
-        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)
-            rescue TypeError, ArgumentError => e
-              raise SchemaError.new(key, value, e.message)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-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/safe.rb

@@ -1,59 +0,0 @@
-require 'dry/types/decorator'
-
-module Dry
-  module Types
-    class Safe
-      include Type
-      include Dry::Equalizer(:type)
-      include Decorator
-      include Builder
-      private :options, :meta
-
-      # @param [Object] input
-      # @return [Object]
-      def call(input)
-        result = try(input)
-
-        if result.respond_to?(:input)
-          result.input
-        else
-          input
-        end
-      end
-      alias_method :[], :call
-
-      # @param [Object] input
-      # @param [#call,nil] block
-      # @yieldparam [Failure] failure
-      # @yieldreturn [Result]
-      # @return [Result,Logic::Result]
-      def try(input, &block)
-        type.try(input, &block)
-      rescue TypeError, ArgumentError => e
-        result = failure(input, e.message)
-        block ? yield(result) : result
-      end
-
-      # @api public
-      #
-      # @see Definition#to_ast
-      def to_ast(meta: true)
-        [:safe, [type.to_ast(meta: meta), EMPTY_HASH]]
-      end
-
-      # @api public
-      # @return [Safe]
-      def safe
-        self
-      end
-
-      private
-
-      # @param [Object, Dry::Types::Constructor] response
-      # @return [Boolean]
-      def decorate?(response)
-        super || response.kind_of?(Constructor)
-      end
-    end
-  end
-end