dry-types 1.4.0 → 1.5.1

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]

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

data/lib/dry/types/result.rb

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

data/lib/dry/types/schema.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/types/fn_container'
+require "dry/types/fn_container"
 
 module Dry
   module Types
@@ -83,7 +83,7 @@ module Dry
         call_unsafe(hash, options)
       end
 
-      # @param [Hash] hash
+      # @param input [Hash] hash
       #
       # @yieldparam [Failure] failure
       # @yieldreturn [Result]
@@ -145,18 +145,10 @@ module Dry
       #
       # @api public
       def to_ast(meta: true)
-        if RUBY_VERSION >= '2.5'
-          opts = options.slice(:key_transform_fn, :type_transform_fn, :strict)
-        else
-          opts = options.select { |k, _|
-            k == :key_transform_fn || k == :type_transform_fn || k == :strict
-          }
-        end
-
         [
           :schema,
           [keys.map { |key| key.to_ast(meta: meta) },
-           opts,
+           options.slice(:key_transform_fn, :type_transform_fn, :strict),
            meta ? self.meta : EMPTY_HASH]
         ]
       end
@@ -190,7 +182,7 @@ module Dry
       def with_key_transform(proc = nil, &block)
         fn = proc || block
 
-        raise ArgumentError, 'a block or callable argument is required' if fn.nil?
+        raise ArgumentError, "a block or callable argument is required" if fn.nil?
 
         handle = Dry::Types::FnContainer.register(fn)
         with(key_transform_fn: handle)
@@ -288,7 +280,7 @@ module Dry
       #
       # A new instance is returned.
       #
-      # @param schema [Schema]
+      # @param other [Schema] schema
       # @return [Schema]
       #
       # @api public

data/lib/dry/types/schema/key.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
-require 'dry/core/deprecations'
+require "dry/core/equalizer"
+require "dry/core/deprecations"
 
 module Dry
   module Types
@@ -136,8 +136,8 @@ module Dry
             super
           else
             self.class.warn(
-              'Using meta for making schema keys is deprecated, ' \
-              'please use .omittable or .required(false) instead' \
+              "Using meta for making schema keys is deprecated, " \
+              "please use .omittable or .required(false) instead" \
               "\n" + Core::Deprecations::STACK.()
             )
             super.required(!data[:omittable])

data/lib/dry/types/spec/types.rb

@@ -1,79 +1,79 @@
 # frozen_string_literal: true
 
-RSpec.shared_examples_for 'Dry::Types::Nominal without primitive' do
+RSpec.shared_examples_for "Dry::Types::Nominal without primitive" do
   def be_boolean
     satisfy { |x| x == true || x == false }
   end
 
-  describe '#constrained?' do
-    it 'returns a boolean value' do
+  describe "#constrained?" do
+    it "returns a boolean value" do
       expect(type.constrained?).to be_boolean
     end
   end
 
-  describe '#default?' do
-    it 'returns a boolean value' do
+  describe "#default?" do
+    it "returns a boolean value" do
       expect(type.default?).to be_boolean
     end
   end
 
-  describe '#valid?' do
-    it 'returns a boolean value' do
+  describe "#valid?" do
+    it "returns a boolean value" do
       expect(type.valid?(1)).to be_boolean
     end
   end
 
-  describe '#eql?' do
-    it 'has #eql? defined' do
+  describe "#eql?" do
+    it "has #eql? defined" do
       expect(type).to eql(type)
     end
   end
 
-  describe '#==' do
-    it 'has #== defined' do
+  describe "#==" do
+    it "has #== defined" do
       expect(type).to eq(type)
     end
   end
 
-  describe '#optional?' do
-    it 'returns a boolean value' do
+  describe "#optional?" do
+    it "returns a boolean value" do
       expect(type.optional?).to be_boolean
     end
   end
 
-  describe '#to_s' do
-    it 'returns a custom string representation' do
-      expect(type.to_s).to start_with('#<Dry::Types') if type.class.name.start_with?('Dry::Types')
+  describe "#to_s" do
+    it "returns a custom string representation" do
+      expect(type.to_s).to start_with("#<Dry::Types") if type.class.name.start_with?("Dry::Types")
     end
   end
 
-  describe '#to_proc' do
+  describe "#to_proc" do
     subject(:callable) { type.to_proc }
 
-    it 'converts a type to a proc' do
+    it "converts a type to a proc" do
       expect(callable).to be_a(Proc)
     end
   end
 end
 
-RSpec.shared_examples_for 'Dry::Types::Nominal#meta' do
-  describe '#meta' do
-    it 'allows setting meta information' do
-      with_meta = type.meta(foo: :bar).meta(baz: '1')
+RSpec.shared_examples_for "Dry::Types::Nominal#meta" do
+  describe "#meta" do
+    it "allows setting meta information" do
+      with_meta = type.meta(foo: :bar).meta(baz: "1")
 
       expect(with_meta).to be_instance_of(type.class)
-      expect(with_meta.meta).to eql(foo: :bar, baz: '1')
+      expect(with_meta.meta).to eql(foo: :bar, baz: "1")
     end
 
-    it 'equalizes on empty meta' do
+    it "equalizes on empty meta" do
       expect(type).to eql(type.meta({}))
     end
 
-    it 'equalizes on filled meta' do
-      expect(type).to_not eql(type.meta(i_am: 'different'))
+    it "equalizes on filled meta" do
+      expect(type).to_not eql(type.meta(i_am: "different"))
     end
 
-    it 'is locally immutable' do
+    it "is locally immutable" do
       expect(type.meta).to be_a ::Hash
       expect(type.meta).to be_frozen
       expect(type.meta).not_to have_key :immutable_test
@@ -84,24 +84,24 @@ RSpec.shared_examples_for 'Dry::Types::Nominal#meta' do
     end
   end
 
-  describe '#pristine' do
-    it 'erases meta' do
+  describe "#pristine" do
+    it "erases meta" do
       expect(type.meta(foo: :bar).pristine).to eql(type)
     end
   end
 end
 
 RSpec.shared_examples_for Dry::Types::Nominal do
-  it_behaves_like 'Dry::Types::Nominal without primitive'
+  it_behaves_like "Dry::Types::Nominal without primitive"
 
-  describe '#primitive' do
-    it 'returns a class' do
+  describe "#primitive" do
+    it "returns a class" do
       expect(type.primitive).to be_instance_of(Class)
     end
   end
 
-  describe '#constructor' do
-    it 'returns a constructor' do
+  describe "#constructor" do
+    it "returns a constructor" do
       constructor = type.constructor(&:to_s)
 
       expect(constructor).to be_a(Dry::Types::Type)
@@ -109,40 +109,52 @@ RSpec.shared_examples_for Dry::Types::Nominal do
   end
 end
 
-RSpec.shared_examples_for 'a constrained type' do |options = { inputs: Object.new }|
+RSpec.shared_examples_for "a constrained type" do |options = {inputs: Object.new}|
   inputs = options[:inputs]
 
   let(:fallback) { Object.new }
 
-  describe '#call' do
-    it 'yields a block on failure' do
+  describe "#call" do
+    it "yields a block on failure" do
       Array(inputs).each do |input|
         expect(type.(input) { fallback }).to be(fallback)
       end
     end
 
-    it 'throws an error on invalid input' do
+    it "throws an error on invalid input" do
       Array(inputs).each do |input|
         expect { type.(input) }.to raise_error(Dry::Types::CoercionError)
       end
     end
   end
+
+  describe "#constructor" do
+    let(:wrapping_constructor) do
+      type.constructor { |input, type| type.(input) { fallback } }
+    end
+
+    it "can be wrapped" do
+      Array(inputs).each do |input|
+        expect(wrapping_constructor.(input)).to be(fallback)
+      end
+    end
+  end
 end
 
-RSpec.shared_examples_for 'a nominal type' do |inputs: Object.new|
-  describe '#call' do
-    it 'always returns the input back' do
+RSpec.shared_examples_for "a nominal type" do |inputs: Object.new|
+  describe "#call" do
+    it "always returns the input back" do
       Array(inputs).each do |input|
-        expect(type.(input) { fail }).to be(input)
+        expect(type.(input) { raise }).to be(input)
         expect(type.(input)).to be(input)
       end
     end
   end
 end
 
-RSpec.shared_examples_for 'a composable constructor' do
-  describe '#constructor' do
-    it 'has aliases for composition' do
+RSpec.shared_examples_for "a composable constructor" do
+  describe "#constructor" do
+    it "has aliases for composition" do
       expect(type.method(:append)).to eql(type.method(:constructor))
       expect(type.method(:prepend)).to eql(type.method(:constructor))
       expect(type.method(:<<)).to eql(type.method(:constructor))