dry-types 1.2.2 → 1.5.1

data/lib/dry/types/inflector.rb

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

data/lib/dry/types/json.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
-require 'dry/types/coercions/json'
+require "dry/types/coercions/json"
 
 module Dry
   module Types
-    register('json.nil') do
-      self['nominal.nil'].constructor(Coercions::JSON.method(:to_nil))
+    register("json.nil") do
+      self["nominal.nil"].constructor(Coercions::JSON.method(:to_nil))
     end
 
-    register('json.date') do
-      self['nominal.date'].constructor(Coercions::JSON.method(:to_date))
+    register("json.date") do
+      self["nominal.date"].constructor(Coercions::JSON.method(:to_date))
     end
 
-    register('json.date_time') do
-      self['nominal.date_time'].constructor(Coercions::JSON.method(:to_date_time))
+    register("json.date_time") do
+      self["nominal.date_time"].constructor(Coercions::JSON.method(:to_date_time))
     end
 
-    register('json.time') do
-      self['nominal.time'].constructor(Coercions::JSON.method(:to_time))
+    register("json.time") do
+      self["nominal.time"].constructor(Coercions::JSON.method(:to_time))
     end
 
-    register('json.decimal') do
-      self['nominal.decimal'].constructor(Coercions::JSON.method(:to_decimal))
+    register("json.decimal") do
+      self["nominal.decimal"].constructor(Coercions::JSON.method(:to_decimal))
     end
 
-    register('json.symbol') do
-      self['nominal.symbol'].constructor(Coercions::JSON.method(:to_symbol))
+    register("json.symbol") do
+      self["nominal.symbol"].constructor(Coercions::JSON.method(:to_symbol))
     end
 
-    register('json.array') { self['array'] }
+    register("json.array") { self["array"] }
 
-    register('json.hash') { self['hash'] }
+    register("json.hash") { self["hash"] }
   end
 end

data/lib/dry/types/lax.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/core/deprecations'
-require 'dry/types/decorator'
+require "dry/core/deprecations"
+require "dry/types/decorator"
 
 module Dry
   module Types
@@ -15,7 +15,7 @@ module Dry
       include Printable
       include Dry::Equalizer(:type, inspect: false, immutable: true)
 
-      undef :options, :constructor
+      undef :options, :constructor, :<<, :>>, :prepend, :append
 
       # @param [Object] input
       #
@@ -40,9 +40,6 @@ module Dry
       # @api public
       def try(input, &block)
         type.try(input, &block)
-      rescue CoercionError => e
-        result = failure(input, e.message)
-        block ? yield(result) : result
       end
 
       # @see Nominal#to_ast

data/lib/dry/types/map.rb

@@ -21,7 +21,7 @@ module Dry
     #
     # @api public
     class Map < Nominal
-      def initialize(_primitive, key_type: Types['any'], value_type: Types['any'], meta: EMPTY_HASH)
+      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)
       end
 
@@ -43,7 +43,7 @@ module Dry
       #
       # @api public
       def name
-        'Map'
+        "Map"
       end
 
       # @param [Hash] hash

data/lib/dry/types/meta.rb

@@ -11,7 +11,7 @@ module Dry
         @meta = meta.freeze
       end
 
-      # @param [Hash] new_options
+      # @param options [Hash] new_options
       #
       # @return [Type]
       #
@@ -28,8 +28,8 @@ module Dry
       #   @return [Type] new type with added metadata
       #
       # @api public
-      def meta(data = nil)
-        if !data
+      def meta(data = Undefined)
+        if Undefined.equal?(data)
           @meta
         elsif data.empty?
           self

data/lib/dry/types/module.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/core/deprecations'
-require 'dry/types/builder_methods'
+require "dry/core/deprecations"
+require "dry/types/builder_methods"
 
 module Dry
   module Types
@@ -31,7 +31,7 @@ module Dry
             base.instance_exec(const_get(:Nominal, false)) do |nominal|
               extend Dry::Core::Deprecations[:'dry-types']
               const_set(:Definition, nominal)
-              deprecate_constant(:Definition, message: 'Nominal')
+              deprecate_constant(:Definition, message: "Nominal")
             end
           end
         end
@@ -69,7 +69,7 @@ module Dry
       def registry_tree
         @registry_tree ||= @registry.keys.each_with_object({}) { |key, tree|
           type = @registry[key]
-          *modules, const_name = key.split('.').map { |part|
+          *modules, const_name = key.split(".").map { |part|
             Inflector.camelize(part).to_sym
           }
           next if modules.empty?
@@ -87,14 +87,14 @@ module Dry
         referenced.concat(aliases.keys)
 
         known = @registry.keys.map { |k|
-          ns, *path = k.split('.')
+          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(', ')}"
+                "Supported options are #{known.map(&:inspect).join(", ")}"
         end
       end
 

data/lib/dry/types/nominal.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require 'dry/core/deprecations'
-require 'dry/types/builder'
-require 'dry/types/result'
-require 'dry/types/options'
-require 'dry/types/meta'
+require "dry/core/deprecations"
+require "dry/core/equalizer"
+require "dry/types/builder"
+require "dry/types/result"
+require "dry/types/options"
+require "dry/types/meta"
 
 module Dry
   module Types
@@ -98,7 +99,6 @@ module Dry
       end
 
       # @param [Object] input
-      # @param [#call,nil] block
       #
       # @yieldparam [Failure] failure
       # @yieldreturn [Result]
@@ -126,7 +126,7 @@ module Dry
       #
       # @api public
       def failure(input, error)
-        raise ArgumentError, 'error must be a CoercionError' unless error.is_a?(CoercionError)
+        raise ArgumentError, "error must be a CoercionError" unless error.is_a?(CoercionError)
 
         Result::Failure.new(input, error)
       end
@@ -201,10 +201,10 @@ module Dry
 
     extend Dry::Core::Deprecations[:'dry-types']
     Definition = Nominal
-    deprecate_constant(:Definition, message: 'Nominal')
+    deprecate_constant(:Definition, message: "Nominal")
   end
 end
 
-require 'dry/types/array'
-require 'dry/types/hash'
-require 'dry/types/map'
+require "dry/types/array"
+require "dry/types/hash"
+require "dry/types/map"

data/lib/dry/types/params.rb

@@ -1,64 +1,67 @@
 # frozen_string_literal: true
 
-require 'dry/types/coercions/params'
+require "dry/types/coercions/params"
 
 module Dry
   module Types
-    register('params.nil') do
-      self['nominal.nil'].constructor(Coercions::Params.method(:to_nil))
+    register("params.nil") do
+      self["nominal.nil"].constructor(Coercions::Params.method(:to_nil))
     end
 
-    register('params.date') do
-      self['nominal.date'].constructor(Coercions::Params.method(:to_date))
+    register("params.date") do
+      self["nominal.date"].constructor(Coercions::Params.method(:to_date))
     end
 
-    register('params.date_time') do
-      self['nominal.date_time'].constructor(Coercions::Params.method(:to_date_time))
+    register("params.date_time") do
+      self["nominal.date_time"].constructor(Coercions::Params.method(:to_date_time))
     end
 
-    register('params.time') do
-      self['nominal.time'].constructor(Coercions::Params.method(:to_time))
+    register("params.time") do
+      self["nominal.time"].constructor(Coercions::Params.method(:to_time))
     end
 
-    register('params.true') do
-      self['nominal.true'].constructor(Coercions::Params.method(:to_true))
+    register("params.true") do
+      self["nominal.true"].constructor(Coercions::Params.method(:to_true))
     end
 
-    register('params.false') do
-      self['nominal.false'].constructor(Coercions::Params.method(:to_false))
+    register("params.false") do
+      self["nominal.false"].constructor(Coercions::Params.method(:to_false))
     end
 
-    register('params.bool') do
-      self['params.true'] | self['params.false']
+    register("params.bool") do
+      self["params.true"] | self["params.false"]
     end
 
-    register('params.integer') do
-      self['nominal.integer'].constructor(Coercions::Params.method(:to_int))
+    register("params.integer") do
+      self["nominal.integer"].constructor(Coercions::Params.method(:to_int))
     end
 
-    register('params.float') do
-      self['nominal.float'].constructor(Coercions::Params.method(:to_float))
+    register("params.float") do
+      self["nominal.float"].constructor(Coercions::Params.method(:to_float))
     end
 
-    register('params.decimal') do
-      self['nominal.decimal'].constructor(Coercions::Params.method(:to_decimal))
+    register("params.decimal") do
+      self["nominal.decimal"].constructor(Coercions::Params.method(:to_decimal))
     end
 
-    register('params.array') do
-      self['nominal.array'].constructor(Coercions::Params.method(:to_ary))
+    register("params.array") do
+      self["nominal.array"].constructor(Coercions::Params.method(:to_ary))
     end
 
-    register('params.hash') do
-      self['nominal.hash'].constructor(Coercions::Params.method(:to_hash))
+    register("params.hash") do
+      self["nominal.hash"].constructor(Coercions::Params.method(:to_hash))
     end
 
-    register('params.symbol') do
-      self['nominal.symbol'].constructor(Coercions::Params.method(:to_symbol))
+    register("params.symbol") do
+      self["nominal.symbol"].constructor(Coercions::Params.method(:to_symbol))
     end
 
+    register("params.string", self["string"])
+
     COERCIBLE.each_key do |name|
       next if name.equal?(:string)
-      register("optional.params.#{name}", self['params.nil'] | self["params.#{name}"])
+
+      register("optional.params.#{name}", self["params.nil"] | self["params.#{name}"])
     end
   end
 end

data/lib/dry/types/predicate_inferrer.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'dry/core/cache'
-require 'dry/types/predicate_registry'
+require "dry/core/cache"
+require "dry/core/class_attributes"
+require "dry/types/predicate_registry"
 
 module Dry
   module Types
@@ -12,13 +13,17 @@ module Dry
       extend Core::Cache
 
       TYPE_TO_PREDICATE = {
-        DateTime => :date_time?,
-        FalseClass => :false?,
-        Integer => :int?,
-        NilClass => :nil?,
-        String => :str?,
-        TrueClass => :true?,
-        BigDecimal => :decimal?
+        ::DateTime => :date_time?,
+        ::Date => :date?,
+        ::Time => :time?,
+        ::FalseClass => :false?,
+        ::Integer => :int?,
+        ::Float => :float?,
+        ::NilClass => :nil?,
+        ::String => :str?,
+        ::TrueClass => :true?,
+        ::BigDecimal => :decimal?,
+        ::Array => :array?
       }.freeze
 
       REDUCED_TYPES = {
@@ -35,6 +40,11 @@ module Dry
       #
       # @api private
       class Compiler
+        extend Core::ClassAttributes
+
+        defines :infer_predicate_by_class_name
+        infer_predicate_by_class_name nil
+
         # @return [PredicateRegistry]
         # @api private
         attr_reader :registry
@@ -46,7 +56,37 @@ module Dry
 
         # @api private
         def infer_predicate(type)
-          [TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }]
+          pred = TYPE_TO_PREDICATE.fetch(type) do
+            if type.name.nil? || self.class.infer_predicate_by_class_name.equal?(false)
+              nil
+            else
+              candidate = :"#{type.name.split("::").last.downcase}?"
+
+              if registry.key?(candidate)
+                if self.class.infer_predicate_by_class_name
+                  candidate
+                else
+                  raise ::KeyError, <<~MESSAGE
+                    Automatic predicate inferring from class names is deprecated
+                    and will be removed in dry-types 2.0.
+                    Use `Dry::Types::PredicateInferrer::Compiler.infer_predicate_by_class_name true`
+                    to restore the previous behavior
+                    or `Dry::Types::PredicateInferrer::Compiler.infer_predicate_by_class_name false`
+                    to explicitly opt-out (i.e. no exception + no inferring).
+                    Note: for dry-schema and dry-validation use Dry::Schema::PredicateInferrer::Compiler.
+                  MESSAGE
+                end
+              else
+                nil
+              end
+            end
+          end
+
+          if pred.nil?
+            EMPTY_ARRAY
+          else
+            [pred]
+          end
         end
 
         # @api private
@@ -60,7 +100,7 @@ module Dry
           type = node[0]
           predicate = infer_predicate(type)
 
-          if registry.key?(predicate[0])
+          if !predicate.empty? && registry.key?(predicate[0])
             predicate
           else
             [type?: type]
@@ -71,6 +111,7 @@ module Dry
         def visit_hash(_)
           HASH
         end
+        alias_method :visit_schema, :visit_hash
 
         # @api private
         def visit_array(_)

data/lib/dry/types/predicate_registry.rb

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

data/lib/dry/types/primitive_inferrer.rb

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

data/lib/dry/types/printer.rb

@@ -7,8 +7,6 @@ module Dry
       MAPPING = {
         Nominal => :visit_nominal,
         Constructor => :visit_constructor,
-        Hash::Constructor => :visit_constructor,
-        Array::Constructor => :visit_constructor,
         Constrained => :visit_constrained,
         Constrained::Coercible => :visit_constrained,
         Hash => :visit_hash,
@@ -27,14 +25,16 @@ module Dry
       }
 
       def call(type)
-        output = ''.dup
+        output = "".dup
         visit(type) { |str| output << str }
         "#<Dry::Types[#{output}]>"
       end
 
       def visit(type, &block)
         print_with = MAPPING.fetch(type.class) do
-          if type.is_a?(Type)
+          if type.class < Constructor
+            :visit_constructor
+          elsif type.is_a?(Type)
             return yield type.inspect
           else
             raise ArgumentError, "Do not know how to print #{type.class}"
@@ -44,7 +44,7 @@ module Dry
       end
 
       def visit_any(_)
-        yield 'Any'
+        yield "Any"
       end
 
       def visit_array(type)
@@ -88,11 +88,11 @@ module Dry
       def visit_schema(schema)
         options = schema.options.dup
         size = schema.count
-        key_fn_str = ''
-        type_fn_str = ''
-        strict_str = ''
+        key_fn_str = ""
+        type_fn_str = ""
+        strict_str = ""
 
-        strict_str = 'strict ' if options.delete(:strict)
+        strict_str = "strict " if options.delete(:strict)
 
         if key_fn = options.delete(:key_transform_fn)
           visit_callable(key_fn) do |fn|
@@ -119,7 +119,7 @@ module Dry
           else
             yield header.dup << keys.map { |key|
               visit(key) { |type| type }
-            }.join(' ') << '}>'
+            }.join(" ") << "}>"
           end
         end
       end
@@ -194,12 +194,12 @@ module Dry
 
           visit_options(options) do |opts|
             if mapping == enum.inverted_mapping
-              values = mapping.values.map(&:inspect).join(', ')
+              values = mapping.values.map(&:inspect).join(", ")
               yield "Enum<#{type} values={#{values}}#{opts}>"
             else
               mapping_str = mapping.map { |key, value|
                 "#{key.inspect}=>#{value.inspect}"
-              }.join(', ')
+              }.join(", ")
               yield "Enum<#{type} mapping={#{mapping_str}}#{opts}>"
             end
           end
@@ -234,7 +234,7 @@ module Dry
 
       def visit_hash(hash)
         options = hash.options.dup
-        type_fn_str = ''
+        type_fn_str = ""
 
         if type_fn = options.delete(:type_transform_fn)
           visit_callable(type_fn) do |fn|
@@ -244,7 +244,7 @@ module Dry
 
         visit_options(options, hash.meta) do |opts|
           if opts.empty? && type_fn_str.empty?
-            yield 'Hash'
+            yield "Hash"
           else
             yield "Hash<#{type_fn_str}#{opts}>"
           end
@@ -255,24 +255,24 @@ module Dry
         fn = callable.is_a?(String) ? FnContainer[callable] : callable
 
         case fn
-        when Method
+        when ::Method
           yield "#{fn.receiver}.#{fn.name}"
-        when Proc
+        when ::Proc
           path, line = fn.source_location
 
           if line&.zero?
             yield ".#{path}"
           elsif path
-            yield "#{path.sub(Dir.pwd + '/', EMPTY_STRING)}:#{line}"
-          elsif fn.lambda?
-            yield '(lambda)'
+            yield "#{path.sub(Dir.pwd + "/", EMPTY_STRING)}:#{line}"
           else
-            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(\w+)\)>\z/)
+            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(?<name>\w+)\)(:? \(lambda\))?>\z/)
 
             if match
-              yield ".#{match[1]}"
+              yield ".#{match[:name]}"
+            elsif fn.lambda?
+              yield "(lambda)"
             else
-              yield '(proc)'
+              yield "(proc)"
             end
           end
         else
@@ -288,9 +288,9 @@ module Dry
 
       def visit_options(options, meta = EMPTY_HASH)
         if options.empty? && meta.empty?
-          yield ''
+          yield ""
         else
-          opts = options.empty? ? '' : " options=#{options.inspect}"
+          opts = options.empty? ? "" : " options=#{options.inspect}"
 
           if meta.empty?
             yield opts
@@ -304,7 +304,7 @@ module Dry
               end
             end
 
-            yield "#{opts} meta={#{values.join(', ')}}"
+            yield "#{opts} meta={#{values.join(", ")}}"
           end
         end
       end