dry-types 0.14.1 → 1.5.1

data/lib/dry/types/enum.rb

@@ -1,11 +1,18 @@
-require 'dry/types/decorator'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/types/decorator"
 
 module Dry
   module Types
+    # Enum types can be used to define an enum on top of an existing type
+    #
+    # @api public
     class Enum
       include Type
-      include Dry::Equalizer(:type, :options, :mapping)
+      include Dry::Equalizer(:type, :mapping, inspect: false, immutable: true)
       include Decorator
+      include Builder
 
       # @return [Array]
       attr_reader :values
@@ -19,7 +26,9 @@ module Dry
       # @param [Type] type
       # @param [Hash] options
       # @option options [Array] :values
-      def initialize(type, options)
+      #
+      # @api private
+      def initialize(type, **options)
         super
         @mapping = options.fetch(:mapping).freeze
         @values = @mapping.keys.freeze
@@ -27,45 +36,59 @@ module Dry
         freeze
       end
 
-      # @param [Object] input
       # @return [Object]
-      def call(input = Undefined)
-        type[map_value(input)]
+      #
+      # @api private
+      def call_unsafe(input)
+        type.call_unsafe(map_value(input))
+      end
+
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &block)
+        type.call_safe(map_value(input), &block)
       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
+      # @see Dry::Types::Constrained#try
+      #
+      # @api public
       def try(input)
         super(map_value(input))
       end
 
+      # @api private
       def default(*)
-        raise '.enum(*values).default(value) is not supported. Call '\
-              '.default(value).enum(*values) instead'
+        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
       #
-      # @see Definition#to_ast
+      # @api public
       def to_ast(meta: true)
-        [:enum, [type.to_ast(meta: meta),
-                 mapping,
-                 meta ? self.meta : EMPTY_HASH]]
+        [:enum, [type.to_ast(meta: meta), mapping]]
+      end
+
+      # @return [String]
+      #
+      # @api public
+      def to_s
+        PRINTER.(self)
       end
+      alias_method :inspect, :to_s
 
       private
 
       # Maps a value
       #
-      # @params [Object]
+      # @param [Object] input
+      #
       # @return [Object]
+      #
       # @api private
       def map_value(input)
         if input.equal?(Undefined)

data/lib/dry/types/errors.rb

@@ -1,14 +1,71 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
-    extend Dry::Core::ClassAttributes
+    extend ::Dry::Core::ClassAttributes
 
     # @!attribute [r] namespace
-    #   @return [Container{String => Definition}]
+    #   @return [Container{String => Nominal}]
     defines :namespace
 
     namespace self
 
-    class SchemaError < TypeError
+    # Base class for coercion errors raise by dry-types
+    #
+    class CoercionError < ::StandardError
+      # @api private
+      def self.handle(exception, meta: Undefined)
+        if block_given?
+          yield
+        else
+          raise new(
+            exception.message,
+            meta: meta,
+            backtrace: exception.backtrace
+          )
+        end
+      end
+
+      # Metadata associated with the error
+      #
+      # @return [Object]
+      attr_reader :meta
+
+      # @api private
+      def initialize(message, meta: Undefined, backtrace: Undefined)
+        unless message.is_a?(::String)
+          raise ::ArgumentError, "message must be a string, #{message.class} given"
+        end
+
+        super(message)
+        @meta = Undefined.default(meta, nil)
+        set_backtrace(backtrace) unless Undefined.equal?(backtrace)
+      end
+    end
+
+    # Collection of multiple errors
+    #
+    class MultipleError < CoercionError
+      # @return [Array<CoercionError>]
+      attr_reader :errors
+
+      # @param [Array<CoercionError>] errors
+      def initialize(errors)
+        @errors = errors
+      end
+
+      # @return string
+      def message
+        errors.map(&:message).join(", ")
+      end
+
+      # @return [Array]
+      def meta
+        errors.map(&:meta)
+      end
+    end
+
+    class SchemaError < CoercionError
       # @param [String,Symbol] key
       # @param [Object] value
       # @param [String, #to_s] result
@@ -17,26 +74,34 @@ module Dry
       end
     end
 
-    MapError = Class.new(TypeError)
+    MapError = ::Class.new(CoercionError)
 
-    SchemaKeyError = Class.new(KeyError)
+    SchemaKeyError = ::Class.new(CoercionError)
     private_constant(:SchemaKeyError)
 
     class MissingKeyError < SchemaKeyError
+      # @return [Symbol]
+      attr_reader :key
+
       # @param [String,Symbol] key
       def initialize(key)
-        super(":#{key} is missing in Hash input")
+        @key = key
+        super("#{key.inspect} is missing in Hash input")
       end
     end
 
     class UnknownKeysError < SchemaKeyError
+      # @return [Array<Symbol>]
+      attr_reader :keys
+
       # @param [<String, Symbol>] keys
-      def initialize(*keys)
+      def initialize(keys)
+        @keys = keys
         super("unexpected keys #{keys.inspect} in Hash input")
       end
     end
 
-    class ConstraintError < TypeError
+    class ConstraintError < CoercionError
       # @return [String, #to_s]
       attr_reader :result
       # @return [Object]
@@ -56,9 +121,10 @@ module Dry
       end
 
       # @return [String]
-      def to_s
+      def message
         "#{input.inspect} violates constraints (#{result} failed)"
       end
+      alias_method :to_s, :message
     end
   end
 end

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

@@ -1,49 +1,83 @@
-require 'dry/monads/maybe'
-require 'dry/types/decorator'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/monads/maybe"
+require "dry/types/decorator"
 
 module Dry
   module Types
+    # Maybe extension provides Maybe types where values are wrapped using `Either` monad
+    #
+    # @api public
     class Maybe
       include Type
-      include Dry::Equalizer(:type, :options)
+      include ::Dry::Equalizer(:type, :options, inspect: false, immutable: true)
       include Decorator
       include Builder
-      include Dry::Monads::Maybe::Mixin
+      include Printable
+      include ::Dry::Monads::Maybe::Mixin
+
+      # @param [Dry::Monads::Maybe, Object] input
+      #
+      # @return [Dry::Monads::Maybe]
+      #
+      # @api private
+      def call_unsafe(input = Undefined)
+        case input
+        when ::Dry::Monads::Maybe
+          input
+        when Undefined
+          None()
+        else
+          Maybe(type.call_unsafe(input))
+        end
+      end
 
       # @param [Dry::Monads::Maybe, Object] input
+      #
       # @return [Dry::Monads::Maybe]
-      def call(input = Undefined)
+      #
+      # @api private
+      def call_safe(input = Undefined)
         case input
-        when Dry::Monads::Maybe
+        when ::Dry::Monads::Maybe
           input
         when Undefined
           None()
         else
-          Maybe(type[input])
+          Maybe(type.call_safe(input) { |output = input| return yield(output) })
         end
       end
-      alias_method :[], :call
 
       # @param [Object] input
+      #
       # @return [Result::Success]
+      #
+      # @api public
       def try(input = Undefined)
-        res = if input.equal?(Undefined)
-                None()
-              else
-                Maybe(type[input])
-              end
+        result = type.try(input)
 
-        Result::Success.new(res)
+        if result.success?
+          Result::Success.new(Maybe(result.input))
+        else
+          result
+        end
       end
 
       # @return [true]
+      #
+      # @api public
       def default?
         true
       end
 
       # @param [Object] value
+      #
       # @see Dry::Types::Builder#default
+      #
       # @raise [ArgumentError] if nil provided as default value
+      #
+      # @api public
       def default(value)
         if value.nil?
           raise ArgumentError, "nil cannot be used as a default of a maybe type"
@@ -54,15 +88,39 @@ module Dry
     end
 
     module Builder
+      # Turn a type into a maybe type
+      #
       # @return [Maybe]
+      #
+      # @api public
+      def maybe
+        Maybe.new(Types["nil"] | self)
+      end
+    end
+
+    # @api private
+    class Schema::Key
+      # @api private
       def maybe
-        Maybe.new(Types['strict.nil'] | self)
+        __new__(type.maybe)
+      end
+    end
+
+    # @api private
+    class Printer
+      MAPPING[Maybe] = :visit_maybe
+
+      # @api private
+      def visit_maybe(maybe)
+        visit(maybe.type) do |type|
+          yield "Maybe<#{type}>"
+        end
       end
     end
 
     # Register non-coercible maybe types
     NON_NIL.each_key do |name|
-      register("maybe.strict.#{name}", self["strict.#{name}"].maybe)
+      register("maybe.strict.#{name}", self[name.to_s].maybe)
     end
 
     # Register coercible maybe types

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "dry/monads/result"
+
+module Dry
+  module Types
+    # Monad extension for Result
+    #
+    # @api public
+    class Result
+      include Dry::Monads::Result::Mixin
+
+      # Turn result into a monad
+      #
+      # This makes result objects work with dry-monads (or anything with a compatible interface)
+      #
+      # @return [Dry::Monads::Success,Dry::Monads::Failure]
+      #
+      # @api public
+      def to_monad
+        if success?
+          Success(input)
+        else
+          Failure([error, input])
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/extensions.rb

@@ -1,3 +1,9 @@
+# frozen_string_literal: true
+
 Dry::Types.register_extension(:maybe) do
-  require 'dry/types/extensions/maybe'
+  require "dry/types/extensions/maybe"
+end
+
+Dry::Types.register_extension(:monads) do
+  require "dry/types/extensions/monads"
 end

data/lib/dry/types/fn_container.rb

@@ -1,7 +1,12 @@
-require 'dry/types/container'
+# frozen_string_literal: true
+
+require "dry/types/container"
 
 module Dry
   module Types
+    # Internal container for constructor functions used by the built-in types
+    #
+    # @api private
     class FnContainer
       # @api private
       def self.container

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dry/types/constructor"
+
+module Dry
+  module Types
+    # Hash type exposes additional APIs for working with schema hashes
+    #
+    # @api public
+    class Hash < Nominal
+      class Constructor < ::Dry::Types::Constructor
+        # @api private
+        def constructor_type
+          ::Dry::Types::Hash::Constructor
+        end
+
+        # @return [Lax]
+        #
+        # @api public
+        def lax
+          type.lax.constructor(fn, meta: meta)
+        end
+
+        # @see Dry::Types::Array#of
+        #
+        # @api public
+        def schema(*args)
+          type.schema(*args).constructor(fn, meta: meta)
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/hash.rb

@@ -1,34 +1,44 @@
-require 'dry/types/hash/schema_builder'
+# frozen_string_literal: true
+
+require "dry/types/hash/constructor"
 
 module Dry
   module Types
-    class Hash < Definition
-      SCHEMA_BUILDER = SchemaBuilder.new.freeze
-
-      # @param [{Symbol => Definition}] type_map
-      # @param [Symbol] constructor
-      # @return [Schema]
-      def schema(type_map, constructor = nil)
-        member_types = transform_types(type_map)
-
-        if constructor.nil?
-          Schema.new(primitive, member_types: member_types, **options, meta: meta)
+    # Hash types can be used to define maps and schemas
+    #
+    # @api public
+    class Hash < Nominal
+      NOT_REQUIRED = {required: false}.freeze
+
+      # @overload schema(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]
+      #
+      # @api public
+      def schema(keys_or_map, meta = EMPTY_HASH)
+        if keys_or_map.is_a?(::Array)
+          keys = keys_or_map
         else
-          SCHEMA_BUILDER.(
-            primitive,
-            **options,
-            member_types: member_types,
-            meta: meta,
-            hash_type: constructor
-          )
+          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]
+      #
+      # @api public
       def map(key_type, value_type)
         Map.new(
           primitive,
@@ -38,81 +48,90 @@ module Dry
         )
       end
 
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def weak(type_map)
-        schema(type_map, :weak)
-      end
-
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def permissive(type_map)
-        schema(type_map, :permissive)
-      end
-
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def strict(type_map)
-        schema(type_map, :strict)
-      end
-
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def strict_with_defaults(type_map)
-        schema(type_map, :strict_with_defaults)
-      end
-
-      # @param [{Symbol => Definition}] type_map
-      # @return [Schema]
-      def symbolized(type_map)
-        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)
+      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
 
       # Injects a type transformation function for building schemas
+      #
       # @param [#call,nil] proc
       # @param [#call,nil] block
+      #
       # @return [Hash]
+      #
+      # @api public
       def with_type_transform(proc = nil, &block)
         fn = proc || block
 
-        if fn.nil?
-          raise ArgumentError, "a block or callable argument is required"
-        end
+        raise ArgumentError, "a block or callable argument is required" if fn.nil?
 
         handle = Dry::Types::FnContainer.register(fn)
-        meta(type_transform_fn: handle)
+        with(type_transform_fn: handle)
+      end
+
+      # @api private
+      def constructor_type
+        ::Dry::Types::Hash::Constructor
+      end
+
+      # 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
+
+      # @param meta [Boolean] Whether to dump the meta to the AST
+      #
+      # @return [Array] An AST representation
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:hash, [options.slice(:type_transform_fn), meta ? self.meta : EMPTY_HASH]]
       end
 
       private
 
       # @api private
-      def transform_types(type_map)
-        type_fn = meta.fetch(:type_transform_fn, Schema::NO_TRANSFORM)
+      def build_keys(type_map)
+        type_fn = options.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
-          )
-        }
+        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]
+        when Type then type
+        when ::Class, ::String 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

@@ -1,4 +1,6 @@
-require 'dry/inflector'
+# frozen_string_literal: true
+
+require "dry/inflector"
 
 module Dry
   module Types