dry-types 0.13.2 → 1.5.1

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