dry-types 0.14.1 → 0.15.0

data/lib/dry/types/container.rb

@@ -1,3 +1,5 @@
+require 'dry/container'
+
 module Dry
   module Types
     class Container

data/lib/dry/types/core.rb

@@ -2,6 +2,7 @@ require 'dry/types/any'
 
 module Dry
   module Types
+    # Primitives with {Kernel} coercion methods
     COERCIBLE = {
       string: String,
       integer: Integer,
@@ -11,6 +12,7 @@ module Dry
       hash: ::Hash
     }.freeze
 
+    # Primitives that are non-coercible through {Kernel} methods
     NON_COERCIBLE = {
       nil: NilClass,
       symbol: Symbol,
@@ -23,41 +25,49 @@ module Dry
       range: Range
     }.freeze
 
+    # All built-in primitives
     ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).freeze
 
+    # All built-in primitives except {NilClass}
     NON_NIL = ALL_PRIMITIVES.reject { |name, _| name == :nil }.freeze
 
-    # Register built-in types that are non-coercible through kernel methods
+    # Register generic types for {ALL_PRIMITIVES}
     ALL_PRIMITIVES.each do |name, primitive|
-      register(name.to_s, Definition[primitive].new(primitive))
+      type = Nominal[primitive].new(primitive)
+      register("nominal.#{name}", type)
     end
 
-    # Register strict built-in types that are non-coercible through kernel methods
+    # Register strict types for {ALL_PRIMITIVES}
     ALL_PRIMITIVES.each do |name, primitive|
-      register("strict.#{name}", self[name.to_s].constrained(type: primitive))
+      type = self["nominal.#{name}"].constrained(type: primitive)
+      register(name.to_s, type)
+      register("strict.#{name}", type)
     end
 
-    # Register built-in primitive types with kernel coercion methods
+    # Register {COERCIBLE} types
     COERCIBLE.each do |name, primitive|
-      register("coercible.#{name}", self[name.to_s].constructor(Kernel.method(primitive.name)))
+      register("coercible.#{name}", self["nominal.#{name}"].constructor(Kernel.method(primitive.name)))
     end
 
-    # Register non-coercible optional types
+    # Register optional strict {NON_NIL} types
     NON_NIL.each_key do |name|
       register("optional.strict.#{name}", self["strict.#{name}"].optional)
     end
 
-    # Register coercible optional types
+    # Register optional {COERCIBLE} types
     COERCIBLE.each_key do |name|
       register("optional.coercible.#{name}", self["coercible.#{name}"].optional)
     end
 
-    # Register :bool since it's common and not a built-in Ruby type :(
-    register("bool", self["true"] | self["false"])
-    register("strict.bool", self["strict.true"] | self["strict.false"])
+    # Register `:bool` since it's common and not a built-in Ruby type :(
+    register("nominal.bool", self["nominal.true"] | self["nominal.false"])
+    bool = self["strict.true"] | self["strict.false"]
+    register("strict.bool", bool)
+    register("bool", bool)
 
     register("any", Any)
-    register("object", self['any'])
+    register("nominal.any", Any)
+    register("strict.any", Any)
   end
 end
 

data/lib/dry/types/default.rb

@@ -4,12 +4,13 @@ module Dry
   module Types
     class Default
       include Type
-      include Dry::Equalizer(:type, :options, :value)
       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]
@@ -67,8 +68,7 @@ module Dry
         if input.equal?(Undefined)
           evaluate
         else
-          output = type[input]
-          output.nil? ? evaluate : output
+          Undefined.default(type[input]) { evaluate }
         end
       end
       alias_method :[], :call

data/lib/dry/types/enum.rb

@@ -4,7 +4,7 @@ module Dry
   module Types
     class Enum
       include Type
-      include Dry::Equalizer(:type, :options, :mapping)
+      include Dry::Equalizer(:type, :options, :mapping, inspect: false)
       include Decorator
 
       # @return [Array]
@@ -53,18 +53,25 @@ module Dry
 
       # @api public
       #
-      # @see Definition#to_ast
+      # @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
       #
-      # @params [Object]
+      # @param [Object]
       # @return [Object]
       # @api private
       def map_value(input)

data/lib/dry/types/errors.rb

@@ -3,7 +3,7 @@ module Dry
     extend Dry::Core::ClassAttributes
 
     # @!attribute [r] namespace
-    #   @return [Container{String => Definition}]
+    #   @return [Container{String => Nominal}]
     defines :namespace
 
     namespace self

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

@@ -5,7 +5,7 @@ module Dry
   module Types
     class Maybe
       include Type
-      include Dry::Equalizer(:type, :options)
+      include Dry::Equalizer(:type, :options, inspect: false)
       include Decorator
       include Builder
       include Dry::Monads::Maybe::Mixin
@@ -60,6 +60,16 @@ module Dry
       end
     end
 
+    class Printer
+      MAPPING[Maybe] = :visit_maybe
+
+      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)

data/lib/dry/types/hash.rb

@@ -1,27 +1,26 @@
-require 'dry/types/hash/schema_builder'
+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)
+    class Hash < Nominal
+      NOT_REQUIRED = { required: false }.freeze
+
+      # @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
-          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
@@ -38,43 +37,16 @@ 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
+      # @param [{Symbol => Nominal}] 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
@@ -88,22 +60,45 @@ module Dry
         end
 
         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
+      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
 
       # @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
@@ -113,6 +108,18 @@ module Dry
         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/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/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

@@ -1,6 +1,6 @@
 module Dry
   module Types
-    class Map < Definition
+    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!
@@ -53,6 +53,11 @@ module Dry
           meta ? self.meta : EMPTY_HASH]]
       end
 
+      # @return [Boolean]
+      def constrained?
+        value_type.constrained?
+      end
+
       private
 
       def coerce(input)

data/lib/dry/types/module.rb

@@ -0,0 +1,115 @@
+require 'dry/core/deprecations'
+require 'dry/types/builder_methods'
+
+module Dry
+  module Types
+    # Export types registered in a container as module constants.
+    # @example
+    #   module Types
+    #     include Dry::Types.module(:strict, :coercible, :nominal, default: :strict)
+    #   end
+    #   # Types.constants
+    #   # => [:Class, :Strict, :Symbol, :Integer, :Float, :String, :Array, :Hash,
+    #   #     :Decimal, :Nil, :True, :False, :Bool, :Date, :Nominal, :DateTime, :Range,
+    #   #     :Coercible, :Time]
+    class Module < ::Module
+      def initialize(registry, *args)
+        @registry = registry
+        check_parameters(*args)
+        constants = type_constants(*args)
+        define_constants(constants)
+        extend(BuilderMethods)
+
+        if constants.key?(:Nominal)
+          singleton_class.send(:define_method, :included) do |base|
+            super(base)
+            base.instance_exec(const_get(:Nominal, false)) do |nominal|
+              extend Dry::Core::Deprecations[:'dry-types']
+              const_set(:Definition, nominal)
+              deprecate_constant(:Definition, message: "Nominal")
+            end
+          end
+        end
+      end
+
+      # @api private
+      def type_constants(*namespaces, default: Undefined, **aliases)
+        if namespaces.empty? && aliases.empty? && Undefined.equal?(default)
+          default_ns = :Strict
+        elsif Undefined.equal?(default)
+          default_ns = Undefined
+        else
+          default_ns = Inflector.camelize(default).to_sym
+        end
+
+        tree = registry_tree
+
+        if namespaces.empty? && aliases.empty?
+          modules = tree.select { |_, v| v.is_a?(::Hash) }.map(&:first)
+        else
+          modules = (namespaces + aliases.keys).map { |n| Inflector.camelize(n).to_sym }
+        end
+
+        tree.each_with_object({}) do |(key, value), constants|
+          if modules.include?(key)
+            name = aliases.fetch(Inflector.underscore(key).to_sym, key)
+            constants[name] = value
+          end
+
+          constants.update(value) if key == default_ns
+        end
+      end
+
+      # @api private
+      def registry_tree
+        @registry_tree ||= @registry.keys.each_with_object({}) { |key, tree|
+          type = @registry[key]
+          *modules, const_name = key.split('.').map { |part|
+            Inflector.camelize(part).to_sym
+          }
+          next if modules.empty?
+
+          modules.reduce(tree) { |br, name| br[name] ||= {} }[const_name] = type
+        }.freeze
+      end
+
+      private
+
+      # @api private
+      def check_parameters(*namespaces, default: Undefined, **aliases)
+        referenced = namespaces.dup
+        referenced << default unless false.equal?(default) || Undefined.equal?(default)
+        referenced.concat(aliases.keys)
+
+        known = @registry.keys.map { |k|
+          ns, *path = k.split('.')
+          ns.to_sym unless path.empty?
+        }.compact.uniq
+
+        (referenced.uniq - known).each do |name|
+          raise ArgumentError,
+                "#{ name.inspect } is not a known type namespace. "\
+                "Supported options are #{ known.map(&:inspect).join(', ') }"
+        end
+      end
+
+      # @api private
+      def define_constants(constants, mod = self)
+        constants.each do |name, value|
+          case value
+          when ::Hash
+            if mod.const_defined?(name, false)
+              define_constants(value, mod.const_get(name, false))
+            else
+              m = ::Module.new
+              mod.const_set(name, m)
+              define_constants(value, m)
+            end
+          else
+            mod.const_set(name, value)
+          end
+        end
+      end
+    end
+  end
+end