dry-types 0.12.3 → 0.13.0

data/lib/dry/types/compat/int.rb

@@ -0,0 +1,13 @@
+require 'dry/core/deprecations'
+
+Dry::Core::Deprecations.warn('Int type was renamed to Integer', tag: :'dry-types')
+
+module Dry
+  module Types
+    register('int', self['integer'])
+    register('strict.int', self['strict.integer'])
+    register('coercible.int', self['coercible.integer'])
+    register('optional.strict.int', self['optional.strict.integer'])
+    register('optional.coercible.int', self['optional.coercible.integer'])
+  end
+end

data/lib/dry/types/compiler.rb

@@ -54,7 +54,8 @@ module Dry
 
       def visit_array(node)
         member, meta = node
-        registry['array'].of(visit(member)).meta(meta)
+        member = member.is_a?(Class) ? member : visit(member)
+        registry['array'].of(member).meta(meta)
       end
 
       def visit_hash(node)
@@ -62,6 +63,11 @@ module Dry
         merge_with('hash', constructor, schema).meta(meta)
       end
 
+      def visit_hash_schema(node)
+        schema, meta = node
+        merge_with_schema('hash', schema).meta(meta)
+      end
+
       def visit_json_hash(node)
         schema, meta = node
         merge_with('json.hash', :symbolized, schema).meta(meta)
@@ -72,14 +78,14 @@ module Dry
         registry['json.array'].of(visit(member)).meta(meta)
       end
 
-      def visit_form_hash(node)
+      def visit_params_hash(node)
         schema, meta = node
-        merge_with('form.hash', :symbolized, schema).meta(meta)
+        merge_with('params.hash', :symbolized, schema).meta(meta)
       end
 
-      def visit_form_array(node)
+      def visit_params_array(node)
         member, meta = node
-        registry['form.array'].of(visit(member)).meta(meta)
+        registry['params.array'].of(visit(member)).meta(meta)
       end
 
       def visit_member(node)
@@ -87,9 +93,26 @@ module Dry
         { name => visit(type) }
       end
 
+      def visit_enum(node)
+        type, mapping, meta = node
+        Enum.new(visit(type), mapping: mapping, meta: meta)
+      end
+
+      def visit_map(node)
+        key_type, value_type, meta = node
+        registry['hash'].map(visit(key_type), visit(value_type)).meta(meta)
+      end
+
       def merge_with(hash_id, constructor, schema)
-        registry[hash_id].__send__(
-          constructor, schema.map { |key| visit(key) }.reduce({}, :update)
+        registry[hash_id].schema(
+          schema.map { |key| visit(key) }.reduce({}, :update),
+          constructor
+        )
+      end
+
+      def merge_with_schema(hash_id, schema)
+        registry[hash_id].instantiate(
+          schema.map { |key| visit(key) }.reduce({}, :update)
         )
       end
     end

data/lib/dry/types/constructor.rb

@@ -1,4 +1,5 @@
 require 'dry/types/decorator'
+require 'dry/types/fn_container'
 
 module Dry
   module Types
@@ -43,6 +44,10 @@ module Dry
         type.name
       end
 
+      def default?
+        type.default?
+      end
+
       # @param [Object] input
       # @return [Object]
       def call(input)

data/lib/dry/types/core.rb

@@ -4,7 +4,7 @@ module Dry
   module Types
     COERCIBLE = {
       string: String,
-      int: Integer,
+      integer: Integer,
       float: Float,
       decimal: BigDecimal,
       array: ::Array,
@@ -19,7 +19,8 @@ module Dry
       false: FalseClass,
       date: Date,
       date_time: DateTime,
-      time: Time
+      time: Time,
+      range: Range
     }.freeze
 
     ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).freeze
@@ -61,5 +62,5 @@ module Dry
 end
 
 require 'dry/types/coercions'
-require 'dry/types/form'
+require 'dry/types/params'
 require 'dry/types/json'

data/lib/dry/types/decorator.rb

@@ -39,6 +39,11 @@ module Dry
         type.constrained?
       end
 
+      # @return [Sum]
+      def optional
+        Types['strict.nil'] | self
+      end
+
       # @param [Symbol] meth
       # @param [Boolean] include_private
       # @return [Boolean]

data/lib/dry/types/default.rb

@@ -59,8 +59,8 @@ module Dry
 
       # @param [Object] input
       # @return [Object] value passed through {#type} or {#default} value
-      def call(input)
-        if input.nil?
+      def call(input = Undefined)
+        if input.equal?(Undefined)
           evaluate
         else
           output = type[input]

data/lib/dry/types/definition.rb

@@ -6,12 +6,9 @@ module Dry
   module Types
     class Definition
       include Type
-      include Dry::Equalizer(:primitive, :options, :meta)
       include Options
       include Builder
-
-      # @return [Hash]
-      attr_reader :options
+      include Dry::Equalizer(:primitive, :options, :meta)
 
       # @return [Class]
       attr_reader :primitive
@@ -84,20 +81,12 @@ module Dry
         Result::Success.new(input)
       end
 
-
       # @param (see Failure#initialize)
       # @return [Result::Failure]
       def failure(input, error)
         Result::Failure.new(input, error)
       end
 
-      # @param [Object] klass class of the result instance
-      # @param [Array] args arguments for the +klass#initialize+ method
-      # @return [Object] new instance of the given +klass+
-      def result(klass, *args)
-        klass.new(*args)
-      end
-
       # Checks whether value is of a #primitive class
       # @param [Object] value
       # @return [Boolean]
@@ -121,3 +110,4 @@ end
 
 require 'dry/types/array'
 require 'dry/types/hash'
+require 'dry/types/map'

data/lib/dry/types/enum.rb

@@ -4,7 +4,7 @@ module Dry
   module Types
     class Enum
       include Type
-      include Dry::Equalizer(:type, :options, :values)
+      include Dry::Equalizer(:type, :options, :mapping)
       include Decorator
 
       # @return [Array]
@@ -13,40 +13,68 @@ module Dry
       # @return [Hash]
       attr_reader :mapping
 
+      # @return [Hash]
+      attr_reader :inverted_mapping
+
       # @param [Type] type
       # @param [Hash] options
       # @option options [Array] :values
       def initialize(type, options)
         super
-        @values = options.fetch(:values).freeze
-        @values.each(&:freeze)
-        @mapping = values.each_with_object({}) { |v, h| h[values.index(v)] = v }.freeze
+        @mapping = options.fetch(:mapping).freeze
+        @values = @mapping.keys.freeze
+        @inverted_mapping = @mapping.invert.freeze
+        freeze
       end
 
       # @param [Object] input
       # @return [Object]
-      def call(input)
-        value =
-          if values.include?(input)
-            input
-          elsif mapping.key?(input)
-            mapping[input]
-          end
-
-        type[value || input]
+      def call(input = Undefined)
+        type[map_value(input)]
       end
       alias_method :[], :call
 
+      # @param [Object] input
+      # @yieldparam [Failure] failure
+      # @yieldreturn [Result]
+      # @return [Logic::Result]
+      # @return [Object] if coercion fails and a block is given
+      def try(input)
+        super(map_value(input))
+      end
+
       def default(*)
         raise '.enum(*values).default(value) is not supported. Call '\
               '.default(value).enum(*values) instead'
       end
 
+      # Check whether a value is in the enum
+      alias_method :include?, :valid?
+
       # @api public
       #
       # @see Definition#to_ast
       def to_ast(meta: true)
-        [:enum, [type.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
+        [:enum, [type.to_ast(meta: meta),
+                 mapping,
+                 meta ? self.meta : EMPTY_HASH]]
+      end
+
+      private
+
+      # Maps a value
+      #
+      # @params [Object]
+      # @return [Object]
+      # @api private
+      def map_value(input)
+        if input.equal?(Undefined)
+          type.call
+        elsif mapping.key?(input)
+          input
+        else
+          inverted_mapping.fetch(input, input)
+        end
       end
     end
   end

data/lib/dry/types/errors.rb

@@ -1,10 +1,12 @@
 module Dry
   module Types
-    extend Dry::Configurable
+    extend Dry::Core::ClassAttributes
 
     # @!attribute [r] namespace
     #   @return [Container{String => Definition}]
-    setting :namespace, self
+    defines :namespace
+
+    namespace self
 
     class SchemaError < TypeError
       # @param [String,Symbol] key
@@ -15,6 +17,8 @@ module Dry
       end
     end
 
+    MapError = Class.new(TypeError)
+
     SchemaKeyError = Class.new(KeyError)
     private_constant(:SchemaKeyError)
 

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.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