dry-types 1.2.1 → 1.5.0

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
@@ -8,7 +8,7 @@ module Dry
     #
     # @api public
     class Result
-      include Dry::Equalizer(:input, inspect: false)
+      include ::Dry::Equalizer(:input, immutable: true)
 
       # @return [Object]
       attr_reader :input
@@ -43,7 +43,7 @@ module Dry
       #
       # @api public
       class Failure < Result
-        include Dry::Equalizer(:input, :error, inspect: false)
+        include ::Dry::Equalizer(:input, :error, immutable: true)
 
         # @return [#to_s]
         attr_reader :error

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
@@ -179,7 +171,7 @@ module Dry
         with(strict: strict)
       end
 
-      # Injects a key transformation function
+      # Inject a key transformation function
       #
       # @param [#call,nil] proc
       # @param [#call,nil] block
@@ -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)
@@ -284,6 +276,27 @@ module Dry
         Lax.new(schema(keys.map(&:lax)))
       end
 
+      # Merge given schema keys into current schema
+      #
+      # A new instance is returned.
+      #
+      # @param other [Schema] schema
+      # @return [Schema]
+      #
+      # @api public
+      def merge(other)
+        schema(other.keys)
+      end
+
+      # Empty schema with the same options
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def clear
+        with(keys: EMPTY_ARRAY)
+      end
+
       private
 
       # @param [Array<Dry::Types::Schema::Keys>] keys

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
@@ -17,7 +17,7 @@ module Dry
       class Key
         extend ::Dry::Core::Deprecations[:'dry-types']
         include Type
-        include Dry::Equalizer(:name, :type, :options, inspect: false)
+        include Dry::Equalizer(:name, :type, :options, inspect: false, immutable: true)
         include Decorator
         include Builder
         include Printable
@@ -31,6 +31,10 @@ module Dry
             type.meta.fetch(:required) { !type.meta.fetch(:omittable, false) }
           end
 
+          unless name.is_a?(::Symbol)
+            raise ArgumentError, "Schemas can only contain symbol keys, #{name.inspect} given"
+          end
+
           super(type, name, required: required, **options)
           @name = name
         end
@@ -99,6 +103,15 @@ module Dry
           __new__(type.lax).required(false)
         end
 
+        # Make wrapped type optional
+        #
+        # @return [Key]
+        #
+        # @api public
+        def optional
+          __new__(type.optional)
+        end
+
         # Dump to internal AST representation
         #
         # @return [Array]
@@ -118,13 +131,13 @@ module Dry
         # @see Dry::Types::Meta#meta
         #
         # @api public
-        def meta(data = nil)
-          if data.nil? || !data.key?(:omittable)
+        def meta(data = Undefined)
+          if Undefined.equal?(data) || !data.key?(:omittable)
             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,33 +109,56 @@ 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
+      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))
+      expect(type.method(:>>)).to eql(type.method(:constructor))
+    end
+  end
+end