dry-types 0.14.0 → 0.15.0

data/lib/dry/types/array.rb

@@ -1,11 +1,8 @@
 require 'dry/types/array/member'
-require 'dry/core/deprecations'
 
 module Dry
   module Types
-    class Array < Definition
-      extend Dry::Core::Deprecations[:'dry-types']
-
+    class Array < Nominal
       # @param [Type] type
       # @return [Array::Member]
       def of(type)

data/lib/dry/types/array/member.rb

@@ -1,6 +1,6 @@
 module Dry
   module Types
-    class Array < Definition
+    class Array < Nominal
       class Member < Array
         # @return [Type]
         attr_reader :member
@@ -51,7 +51,7 @@ module Dry
 
         # @api public
         #
-        # @see Definition#to_ast
+        # @see Nominal#to_ast
         def to_ast(meta: true)
           if member.respond_to?(:to_ast)
             [:array, [member.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]

data/lib/dry/types/builder.rb

@@ -1,3 +1,5 @@
+require 'dry/core/deprecations'
+
 module Dry
   module Types
     module Builder
@@ -8,6 +10,11 @@ module Dry
         Constrained
       end
 
+      # @return [Class]
+      def constructor_type
+        Constructor
+      end
+
       # @param [Type] other
       # @return [Sum, Sum::Constrained]
       def |(other)
@@ -27,13 +34,26 @@ module Dry
       end
 
       # @param [Object] input
+      # @param [Hash] options
       # @param [#call,nil] block
       # @raise [ConstraintError]
       # @return [Default]
-      def default(input = Undefined, &block)
+      def default(input = Undefined, options = EMPTY_HASH, &block)
+        unless input.frozen? || options[:shared]
+          where = Dry::Core::Deprecations::STACK.()
+          Dry::Core::Deprecations.warn(
+            "#{input.inspect} is mutable."\
+            ' Be careful: types will return the same instance of the default'\
+            ' value every time. Call `.freeze` when setting the default'\
+            ' or pass `shared: true` to discard this warning.'\
+            "\n#{ where }",
+            tag: :'dry-types'
+          )
+        end
+
         value = input.equal?(Undefined) ? block : input
 
-        if value.is_a?(Proc) || valid?(value)
+        if value.respond_to?(:call) || valid?(value)
           Default[value].new(self, value)
         else
           raise ConstraintError.new("default value #{value.inspect} violates constraints", value)
@@ -63,7 +83,7 @@ module Dry
       # @param [#call,nil] block
       # @return [Constructor]
       def constructor(constructor = nil, **options, &block)
-        Constructor.new(with(options), fn: constructor || block)
+        constructor_type.new(with(options), fn: constructor || block)
       end
     end
   end

data/lib/dry/types/builder_methods.rb

@@ -22,13 +22,12 @@ module Dry
 
       # Build a hash schema
       #
-      # @param [Symbol] schema Schema type
       # @param [Hash{Symbol => Dry::Types::Type}] type_map
       #
       # @return [Dry::Types::Array]
       # @api public
-      def Hash(schema, type_map)
-        self::Hash.public_send(schema, type_map)
+      def Hash(type_map)
+        self::Hash.schema(type_map)
       end
 
       # Build a type which values are instances of a given class
@@ -44,7 +43,7 @@ module Dry
       # @return [Dry::Types::Type]
       # @api public
       def Instance(klass)
-        Definition.new(klass).constrained(type: klass)
+        Nominal.new(klass).constrained(type: klass)
       end
       alias_method :Strict, :Instance
 
@@ -56,7 +55,7 @@ module Dry
       # @return [Dry::Types::Type]
       # @api public
       def Value(value)
-        Definition.new(value.class).constrained(eql: value)
+        Nominal.new(value.class).constrained(eql: value)
       end
 
       # Build a type with a single value
@@ -67,7 +66,7 @@ module Dry
       # @return [Dry::Types::Type]
       # @api public
       def Constant(object)
-        Definition.new(object.class).constrained(is: object)
+        Nominal.new(object.class).constrained(is: object)
       end
 
       # Build a constructor type
@@ -80,17 +79,17 @@ module Dry
       # @return [Dry::Types::Type]
       # @api public
       def Constructor(klass, cons = nil, &block)
-        Definition.new(klass).constructor(cons || block || klass.method(:new))
+        Nominal.new(klass).constructor(cons || block || klass.method(:new))
       end
 
-      # Build a definition type
+      # Build a nominal type
       #
       # @param [Class] klass
       #
       # @return [Dry::Types::Type]
       # @api public
-      def Definition(klass)
-        Definition.new(klass)
+      def Nominal(klass)
+        Nominal.new(klass)
       end
 
       # Build a map type
@@ -105,7 +104,7 @@ module Dry
       # @return [Dry::Types::Map]
       # @api public
       def Map(key_type, value_type)
-        Types['hash'].map(key_type, value_type)
+        Types['nominal.hash'].map(key_type, value_type)
       end
     end
   end

data/lib/dry/types/coercions/params.rb

@@ -32,6 +32,8 @@ module Dry
         def self.to_int(input)
           if empty_str?(input)
             nil
+          elsif input.is_a? String
+            Integer(input, 10)
           else
             Integer(input)
           end

data/lib/dry/types/compat.rb

@@ -1,2 +0,0 @@
-require 'dry/types/compat/int'
-require 'dry/types/compat/form_types'

data/lib/dry/types/compiler.rb

@@ -17,14 +17,14 @@ module Dry
       end
 
       def visit_constrained(node)
-        definition, rule, meta = node
-        Types::Constrained.new(visit(definition), rule: visit_rule(rule)).meta(meta)
+        nominal, rule, meta = node
+        Types::Constrained.new(visit(nominal), rule: visit_rule(rule)).meta(meta)
       end
 
       def visit_constructor(node)
-        definition, fn_register_name, meta = node
+        nominal, fn_register_name, meta = node
         fn = Dry::Types::FnContainer[fn_register_name]
-        primitive = visit(definition)
+        primitive = visit(nominal)
         Types::Constructor.new(primitive, meta: meta, fn: fn)
       end
 
@@ -33,13 +33,14 @@ module Dry
         Types::Safe.new(visit(ast), meta: meta)
       end
 
-      def visit_definition(node)
+      def visit_nominal(node)
         type, meta = node
+        nominal_name = "nominal.#{ Types.identifier(type) }"
 
-        if registry.registered?(type)
-          registry[type].meta(meta)
+        if registry.registered?(nominal_name)
+          registry[nominal_name].meta(meta)
         else
-          Definition.new(type, meta: meta)
+          Nominal.new(type, meta: meta)
         end
       end
 
@@ -55,22 +56,22 @@ module Dry
       def visit_array(node)
         member, meta = node
         member = member.is_a?(Class) ? member : visit(member)
-        registry['array'].of(member).meta(meta)
+        registry['nominal.array'].of(member).meta(meta)
       end
 
       def visit_hash(node)
-        constructor, schema, meta = node
-        merge_with('hash', constructor, schema).meta(meta)
+        opts, meta = node
+        registry['nominal.hash'].with(opts.merge(meta: meta))
       end
 
-      def visit_hash_schema(node)
-        schema, meta = node
-        merge_with_schema('hash', schema).meta(meta)
+      def visit_schema(node)
+        keys, options, meta = node
+        registry['nominal.hash'].schema(keys.map { |key| visit(key) }).with(options.merge(meta: meta))
       end
 
       def visit_json_hash(node)
-        schema, meta = node
-        merge_with('json.hash', :symbolized, schema).meta(meta)
+        keys, meta = node
+        registry['json.hash'].schema(keys.map { |key| visit(key) }, meta)
       end
 
       def visit_json_array(node)
@@ -79,8 +80,8 @@ module Dry
       end
 
       def visit_params_hash(node)
-        schema, meta = node
-        merge_with('params.hash', :symbolized, schema).meta(meta)
+        keys, meta = node
+        registry['params.hash'].schema(keys.map { |key| visit(key) }, meta)
       end
 
       def visit_params_array(node)
@@ -88,9 +89,9 @@ module Dry
         registry['params.array'].of(visit(member)).meta(meta)
       end
 
-      def visit_member(node)
-        name, type = node
-        { name => visit(type) }
+      def visit_key(node)
+        name, required, type = node
+        Schema::Key.new(visit(type), name, required: required)
       end
 
       def visit_enum(node)
@@ -100,20 +101,11 @@ module Dry
 
       def visit_map(node)
         key_type, value_type, meta = node
-        registry['hash'].map(visit(key_type), visit(value_type)).meta(meta)
+        registry['nominal.hash'].map(visit(key_type), visit(value_type)).meta(meta)
       end
 
-      def merge_with(hash_id, constructor, schema)
-        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)
-        )
+      def visit_any(meta)
+        registry['any'].meta(meta)
       end
     end
   end

data/lib/dry/types/constrained.rb

@@ -6,9 +6,10 @@ module Dry
   module Types
     class Constrained
       include Type
-      include Dry::Equalizer(:type, :options, :rule, :meta)
       include Decorator
       include Builder
+      include Printable
+      include Dry::Equalizer(:type, :options, :rule, :meta, inspect: false)
 
       # @return [Dry::Logic::Rule]
       attr_reader :rule
@@ -24,9 +25,9 @@ module Dry
       # @return [Object]
       # @raise [ConstraintError]
       def call(input)
-        try(input) do |result|
+        try(input) { |result|
           raise ConstraintError.new(result, input)
-        end.input
+        }.input
       end
       alias_method :[], :call
 
@@ -75,7 +76,7 @@ module Dry
 
       # @api public
       #
-      # @see Definition#to_ast
+      # @see Nominal#to_ast
       def to_ast(meta: true)
         [:constrained, [type.to_ast(meta: meta),
                         rule.to_ast,

data/lib/dry/types/constructor.rb

@@ -2,8 +2,8 @@ require 'dry/types/fn_container'
 
 module Dry
   module Types
-    class Constructor < Definition
-      include Dry::Equalizer(:type, :options, :meta)
+    class Constructor < Nominal
+      include Dry::Equalizer(:type, :options, :meta, inspect: false)
 
       # @return [#call]
       attr_reader :fn
@@ -17,7 +17,7 @@ module Dry
       # @param [Hash] options
       # @param [#call, nil] block
       def self.new(input, **options, &block)
-        type = input.is_a?(Builder) ? input : Definition.new(input)
+        type = input.is_a?(Builder) ? input : Nominal.new(input)
         super(type, **options, &block)
       end
 
@@ -43,6 +43,7 @@ module Dry
         type.name
       end
 
+      # @return [Boolean]
       def default?
         type.default?
       end
@@ -72,14 +73,16 @@ module Dry
         left = new_fn || block
         right = fn
 
-        with(options.merge(fn: -> input { left[right[input]] }))
+        with(**options, fn: -> input { left[right[input]] })
       end
+      alias_method :append, :constructor
+      alias_method :>>, :constructor
 
       # @param [Object] value
       # @return [Boolean]
       def valid?(value)
         constructed_value = fn[value]
-      rescue NoMethodError, TypeError
+      rescue NoMethodError, TypeError, ArgumentError
         false
       else
         type.valid?(constructed_value)
@@ -93,13 +96,27 @@ module Dry
 
       # @api public
       #
-      # @see Definition#to_ast
+      # @see Nominal#to_ast
       def to_ast(meta: true)
         [:constructor, [type.to_ast(meta: meta),
                         register_fn(fn),
                         meta ? self.meta : EMPTY_HASH]]
       end
 
+      # @api public
+      #
+      # @param [#call, nil] new_fn
+      # @param [Hash] options
+      # @param [#call, nil] block
+      # @return [Constructor]
+      def prepend(new_fn = nil, **options, &block)
+        left = new_fn || block
+        right = fn
+
+        with(**options, fn: -> input { right[left[input]] })
+      end
+      alias_method :<<, :prepend
+
       private
 
       def register_fn(fn)
@@ -114,15 +131,15 @@ module Dry
       end
 
       # Delegates missing methods to {#type}
-      # @param [Symbol] meth
+      # @param [Symbol] method
       # @param [Array] args
       # @param [#call, nil] block
-      def method_missing(meth, *args, &block)
-        if type.respond_to?(meth)
-          response = type.__send__(meth, *args, &block)
+      def method_missing(method, *args, &block)
+        if type.respond_to?(method)
+          response = type.__send__(method, *args, &block)
 
-          if response.kind_of?(Builder)
-            self.class.new(response, options)
+          if composable?(response)
+            response.constructor_type.new(response, options)
           else
             response
           end
@@ -130,6 +147,10 @@ module Dry
           super
         end
       end
+
+      def composable?(value)
+        value.kind_of?(Builder)
+      end
     end
   end
 end

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