dry-types 0.9.0 → 0.15.0

data/lib/dry/types/default.rb

@@ -3,22 +3,29 @@ require 'dry/types/decorator'
 module Dry
   module Types
     class Default
-      include Dry::Equalizer(:type, :options, :value)
+      include Type
       include Decorator
       include Builder
+      include Printable
+      include Dry::Equalizer(:type, :options, :value, inspect: false)
 
       class Callable < Default
-        include Dry::Equalizer(:type, :options)
+        include Dry::Equalizer(:type, :options, inspect: false)
 
+        # Evaluates given callable
+        # @return [Object]
         def evaluate
-          value.call
+          value.call(type)
         end
       end
 
+      # @return [Object]
       attr_reader :value
 
       alias_method :evaluate, :value
 
+      # @param [Object, #call] value
+      # @return [Class] {Default} or {Default::Callable}
       def self.[](value)
         if value.respond_to?(:call)
           Callable
@@ -27,32 +34,51 @@ module Dry
         end
       end
 
-      def initialize(type, value, *)
+      # @param [Type] type
+      # @param [Object] value
+      def initialize(type, value, **options)
         super
         @value = value
       end
 
+      # @param [Array] args see {Dry::Types::Builder#constrained}
+      # @return [Default]
       def constrained(*args)
         type.constrained(*args).default(value)
       end
 
+      # @return [true]
       def default?
         true
       end
 
+      # @param [Object] input
+      # @return [Result::Success]
       def try(input)
         success(call(input))
       end
 
-      def call(input)
-        if input.nil?
+      def valid?(value = Undefined)
+        value.equal?(Undefined) || super
+      end
+
+      # @param [Object] input
+      # @return [Object] value passed through {#type} or {#default} value
+      def call(input = Undefined)
+        if input.equal?(Undefined)
           evaluate
         else
-          output = type[input]
-          output.nil? ? evaluate : output
+          Undefined.default(type[input]) { evaluate }
         end
       end
       alias_method :[], :call
+
+      private
+
+      # Replace underlying type
+      def __new__(type)
+        self.class.new(type, value, options)
+      end
     end
   end
 end

data/lib/dry/types/enum.rb

@@ -3,29 +3,86 @@ require 'dry/types/decorator'
 module Dry
   module Types
     class Enum
-      include Dry::Equalizer(:type, :options, :values)
+      include Type
+      include Dry::Equalizer(:type, :options, :mapping, inspect: false)
       include Decorator
 
-      attr_reader :values, :mapping
+      # @return [Array]
+      attr_reader :values
 
+      # @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
 
-      def call(input)
-        value =
-          if values.include?(input)
-            input
-          elsif mapping.key?(input)
-            mapping[input]
-          end
-
-        type[value || input]
+      # @param [Object] input
+      # @return [Object]
+      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 Nominal#to_ast
+      def to_ast(meta: true)
+        [:enum, [type.to_ast(meta: meta),
+                 mapping,
+                 meta ? self.meta : EMPTY_HASH]]
+      end
+
+      # @return [String]
+      # @api public
+      def to_s
+        PRINTER.(self)
+      end
+      alias_method :inspect, :to_s
+
+      private
+
+      # Maps a value
+      #
+      # @param [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
 end

data/lib/dry/types/errors.rb

@@ -1,33 +1,49 @@
 module Dry
   module Types
-    extend Dry::Configurable
+    extend Dry::Core::ClassAttributes
 
-    setting :namespace, self
+    # @!attribute [r] namespace
+    #   @return [Container{String => Nominal}]
+    defines :namespace
+
+    namespace self
 
     class SchemaError < TypeError
-      def initialize(key, value)
-        super("#{value.inspect} (#{value.class}) has invalid type for :#{key}")
+      # @param [String,Symbol] key
+      # @param [Object] value
+      # @param [String, #to_s] result
+      def initialize(key, value, result)
+        super("#{value.inspect} (#{value.class}) has invalid type for :#{key} violates constraints (#{result} failed)")
       end
     end
 
+    MapError = Class.new(TypeError)
+
     SchemaKeyError = Class.new(KeyError)
     private_constant(:SchemaKeyError)
 
     class MissingKeyError < SchemaKeyError
+      # @param [String,Symbol] key
       def initialize(key)
         super(":#{key} is missing in Hash input")
       end
     end
 
     class UnknownKeysError < SchemaKeyError
+      # @param [<String, Symbol>] keys
       def initialize(*keys)
         super("unexpected keys #{keys.inspect} in Hash input")
       end
     end
 
-    ConstraintError = Class.new(TypeError) do
-      attr_reader :result, :input
+    class ConstraintError < TypeError
+      # @return [String, #to_s]
+      attr_reader :result
+      # @return [Object]
+      attr_reader :input
 
+      # @param [String, #to_s] result
+      # @param [Object] input
       def initialize(result, input)
         @result = result
         @input = input
@@ -39,6 +55,7 @@ module Dry
         end
       end
 
+      # @return [String]
       def to_s
         "#{input.inspect} violates constraints (#{result} failed)"
       end

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

@@ -4,24 +4,46 @@ require 'dry/types/decorator'
 module Dry
   module Types
     class Maybe
-      include Dry::Equalizer(:type, :options)
+      include Type
+      include Dry::Equalizer(:type, :options, inspect: false)
       include Decorator
       include Builder
       include Dry::Monads::Maybe::Mixin
 
-      def call(input)
-        input.is_a?(Dry::Monads::Maybe) ? input : Maybe(type[input])
+      # @param [Dry::Monads::Maybe, Object] input
+      # @return [Dry::Monads::Maybe]
+      def call(input = Undefined)
+        case input
+        when Dry::Monads::Maybe
+          input
+        when Undefined
+          None()
+        else
+          Maybe(type[input])
+        end
       end
       alias_method :[], :call
 
-      def try(input)
-        Result::Success.new(Maybe(type[input]))
+      # @param [Object] input
+      # @return [Result::Success]
+      def try(input = Undefined)
+        res = if input.equal?(Undefined)
+                None()
+              else
+                Maybe(type[input])
+              end
+
+        Result::Success.new(res)
       end
 
-      def maybe?
+      # @return [true]
+      def default?
         true
       end
 
+      # @param [Object] value
+      # @see Dry::Types::Builder#default
+      # @raise [ArgumentError] if nil provided as default value
       def default(value)
         if value.nil?
           raise ArgumentError, "nil cannot be used as a default of a maybe type"
@@ -32,23 +54,20 @@ module Dry
     end
 
     module Builder
+      # @return [Maybe]
       def maybe
         Maybe.new(Types['strict.nil'] | self)
       end
     end
 
-    class Hash
-      module MaybeTypes
-        def resolve_missing_value(result, key, type)
-          if type.respond_to?(:maybe?) && type.maybe?
-            result[key] = type[nil]
-          else
-            super
-          end
+    class Printer
+      MAPPING[Maybe] = :visit_maybe
+
+      def visit_maybe(maybe)
+        visit(maybe.type) do |type|
+          yield "Maybe<#{ type }>"
         end
       end
-
-      Schema.include MaybeTypes
     end
 
     # Register non-coercible maybe types

data/lib/dry/types/fn_container.rb

@@ -0,0 +1,34 @@
+require 'dry/types/container'
+
+module Dry
+  module Types
+    class FnContainer
+      # @api private
+      def self.container
+        @container ||= Container.new
+      end
+
+      # @api private
+      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.[](fn_name)
+        if container.key?(fn_name)
+          container[fn_name]
+        else
+          fn_name
+        end
+      end
+
+      # @api private
+      def self.register_name(function)
+        "fn_#{function.object_id}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'dry/types/constructor'
+
+module Dry
+  module Types
+    class Hash < Nominal
+      class Constructor < ::Dry::Types::Constructor
+        # @api private
+        def constructor_type
+          ::Dry::Types::Hash::Constructor
+        end
+
+        private
+
+        def composable?(value)
+          super && !value.is_a?(Schema::Key)
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/hash.rb

@@ -1,45 +1,125 @@
-require 'dry/types/hash/schema'
+require 'dry/types/hash/constructor'
 
 module Dry
   module Types
-    class Hash < Definition
-      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
-        }
+    class Hash < Nominal
+      NOT_REQUIRED = { required: false }.freeze
 
-        klass.new(primitive, options.merge(member_types: member_types))
+      # @overload schmea(type_map, meta = EMPTY_HASH)
+      #   @param [{Symbol => Dry::Types::Nominal}] type_map
+      #   @param [Hash] meta
+      #   @return [Dry::Types::Schema]
+      # @overload schema(keys)
+      #   @param [Array<Dry::Types::Schema::Key>] key List of schema keys
+      #   @param [Hash] meta
+      #   @return [Dry::Types::Schema]
+      def schema(keys_or_map, meta = EMPTY_HASH)
+        if keys_or_map.is_a?(::Array)
+          keys = keys_or_map
+        else
+          keys = build_keys(keys_or_map)
+        end
+
+        Schema.new(primitive, keys: keys, **options, meta: self.meta.merge(meta))
+      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
 
-      def weak(type_map)
-        schema(type_map, Weak)
+      # @param [{Symbol => Nominal}] type_map
+      # @return [Schema]
+      def weak(*)
+        raise "Support for old hash schemas was removed, please refer to the CHANGELOG "\
+              "on how to proceed with the new API https://github.com/dry-rb/dry-types/blob/master/CHANGELOG.md"
       end
+      alias_method :permissive, :weak
+      alias_method :strict, :weak
+      alias_method :strict_with_defaults, :weak
+      alias_method :symbolized, :weak
 
-      def permissive(type_map)
-        schema(type_map, Permissive)
+      # 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)
+        with(type_transform_fn: handle)
       end
 
-      def strict(type_map)
-        schema(type_map, Strict)
+      # @api private
+      def constructor_type
+        ::Dry::Types::Hash::Constructor
       end
 
-      def strict_with_defaults(type_map)
-        schema(type_map, StrictWithDefaults)
+      # Whether the type transforms types of schemas created by {Dry::Types::Hash#schema}
+      # @return [Boolean]
+      # @api public
+      def transform_types?
+        !options[:type_transform_fn].nil?
       end
 
-      def symbolized(type_map)
-        schema(type_map, Symbolized)
+      # @param meta [Boolean] Whether to dump the meta to the AST
+      # @return [Array] An AST representation
+      def to_ast(meta: true)
+        if RUBY_VERSION >= "2.5"
+          opts = options.slice(:type_transform_fn)
+        else
+          opts = options.select { |k, _| k == :type_transform_fn }
+        end
+
+        [:hash, [opts, meta ? self.meta : EMPTY_HASH]]
       end
 
       private
 
-      def resolve_missing_value(_result, _key, _type)
-        # noop
+      # @api private
+      def build_keys(type_map)
+        type_fn = options.fetch(:type_transform_fn, Schema::NO_TRANSFORM)
+        type_transform = Dry::Types::FnContainer[type_fn]
+
+        type_map.map do |map_key, type|
+          name, options = key_name(map_key)
+          key = Schema::Key.new(resolve_type(type), name, options)
+          type_transform.(key)
+        end
+      end
+
+      # @api private
+      def resolve_type(type)
+        case type
+        when String, Class then Types[type]
+        else type
+        end
+      end
+
+      # @api private
+      def key_name(key)
+        if key.to_s.end_with?('?')
+          [key.to_s.chop.to_sym, NOT_REQUIRED]
+        else
+          [key, EMPTY_HASH]
+        end
       end
     end
   end
 end
+
+require 'dry/types/schema/key'
+require 'dry/types/schema'

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/json.rb

@@ -3,31 +3,31 @@ require 'dry/types/coercions/json'
 module Dry
   module Types
     register('json.nil') do
-      self['nil'].constructor(Coercions::JSON.method(:to_nil))
+      self['nominal.nil'].constructor(Coercions::JSON.method(:to_nil))
     end
 
     register('json.date') do
-      self['date'].constructor(Coercions::JSON.method(:to_date))
+      self['nominal.date'].constructor(Coercions::JSON.method(:to_date))
     end
 
     register('json.date_time') do
-      self['date_time'].constructor(Coercions::JSON.method(:to_date_time))
+      self['nominal.date_time'].constructor(Coercions::JSON.method(:to_date_time))
     end
 
     register('json.time') do
-      self['time'].constructor(Coercions::JSON.method(:to_time))
+      self['nominal.time'].constructor(Coercions::JSON.method(:to_time))
     end
 
     register('json.decimal') do
-      self['decimal'].constructor(Coercions::JSON.method(:to_decimal))
+      self['nominal.decimal'].constructor(Coercions::JSON.method(:to_decimal))
     end
 
     register('json.array') do
-      self['array'].safe
+      self['nominal.array'].safe
     end
 
     register('json.hash') do
-      self['hash'].safe
+      self['nominal.hash'].safe
     end
   end
 end

data/lib/dry/types/map.rb

@@ -0,0 +1,98 @@
+module Dry
+  module Types
+    class Map < Nominal
+      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
+
+      # @return [Boolean]
+      def constrained?
+        value_type.constrained?
+      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