dry-types 0.15.0 → 1.5.1

data/lib/dry/types/schema.rb

@@ -1,4 +1,6 @@
-require 'dry/types/fn_container'
+# frozen_string_literal: true
+
+require "dry/types/fn_container"
 
 module Dry
   module Types
@@ -14,6 +16,8 @@ module Dry
     # @see Dry::Types::Default::Callable#evaluate
     #
     # {Schema} implements Enumerable using its keys as collection.
+    #
+    # @api public
     class Schema < Hash
       NO_TRANSFORM = Dry::Types::FnContainer.register { |x| x }
       SYMBOLIZE_KEY = Dry::Types::FnContainer.register(:to_sym.to_proc)
@@ -31,8 +35,11 @@ module Dry
 
       # @param [Class] _primitive
       # @param [Hash] options
+      #
       # @option options [Array[Dry::Types::Schema::Key]] :keys
       # @option options [String] :key_transform_fn
+      #
+      # @api private
       def initialize(_primitive, **options)
         @keys = options.fetch(:keys)
         @name_key_map = keys.each_with_object({}) do |key, idx|
@@ -47,116 +54,146 @@ module Dry
       end
 
       # @param [Hash] hash
+      #
       # @return [Hash{Symbol => Object}]
-      def call(hash)
-        coerce(hash)
+      #
+      # @api private
+      def call_unsafe(hash, options = EMPTY_HASH)
+        resolve_unsafe(coerce(hash), options)
+      end
+
+      # @param [Hash] hash
+      #
+      # @return [Hash{Symbol => Object}]
+      #
+      # @api private
+      def call_safe(hash, options = EMPTY_HASH)
+        resolve_safe(coerce(hash) { return yield }, options) { return yield }
       end
-      alias_method :[], :call
 
       # @param [Hash] hash
+      #
       # @option options [Boolean] :skip_missing If true don't raise error if on missing keys
       # @option options [Boolean] :resolve_defaults If false default value
       #                                             won't be evaluated for missing key
       # @return [Hash{Symbol => Object}]
+      #
+      # @api public
       def apply(hash, options = EMPTY_HASH)
-        coerce(hash, options)
+        call_unsafe(hash, options)
       end
 
-      # @param [Hash] hash
+      # @param input [Hash] hash
+      #
       # @yieldparam [Failure] failure
       # @yieldreturn [Result]
+      #
       # @return [Logic::Result]
       # @return [Object] if coercion fails and a block is given
-      def try(hash)
-        if hash.is_a?(::Hash)
+      #
+      # @api public
+      def try(input)
+        if primitive?(input)
           success = true
-          output  = {}
+          output = {}
+          result = {}
 
-          begin
-            result = try_coerce(hash) do |key, key_result|
+          input.each do |key, value|
+            k = @transform_key.(key)
+            type = @name_key_map[k]
+
+            if type
+              key_result = type.try(value)
+              result[k] = key_result
+              output[k] = key_result.input
               success &&= key_result.success?
-              output[key.name] = key_result.input
+            elsif strict?
+              success = false
+            end
+          end
 
-              key_result
+          if output.size < keys.size
+            resolve_missing_keys(output, options) do
+              success = false
             end
-          rescue ConstraintError, UnknownKeysError, SchemaError, MissingKeyError => e
-            success = false
-            result = e
+          end
+
+          success &&= primitive?(output)
+
+          if success
+            failure = nil
+          else
+            error = CoercionError.new("#{input} doesn't conform schema", meta: result)
+            failure = failure(output, error)
           end
         else
-          success = false
-          output = hash
-          result = "#{hash} must be a hash"
+          failure = failure(input, CoercionError.new("#{input} must be a hash"))
         end
 
-        if success
+        if failure.nil?
           success(output)
+        elsif block_given?
+          yield(failure)
         else
-          failure = failure(output, result)
-          block_given? ? yield(failure) : failure
+          failure
         end
       end
 
       # @param meta [Boolean] Whether to dump the meta to the AST
+      #
       # @return [Array] An AST representation
+      #
+      # @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,
-            meta ? self.meta : EMPTY_HASH
-          ]
+          [keys.map { |key| key.to_ast(meta: meta) },
+           options.slice(:key_transform_fn, :type_transform_fn, :strict),
+           meta ? self.meta : EMPTY_HASH]
         ]
       end
 
-      # @param [Hash] hash
-      # @return [Boolean]
-      def valid?(hash)
-        result = try(hash)
-        result.success?
-      end
-      alias_method :===, :valid?
-
       # Whether the schema rejects unknown keys
+      #
       # @return [Boolean]
+      #
+      # @api public
       def strict?
         options.fetch(:strict, false)
       end
 
       # Make the schema intolerant to unknown keys
+      #
       # @return [Schema]
-      def strict
-        with(strict: true)
+      #
+      # @api public
+      def strict(strict = true)
+        with(strict: strict)
       end
 
-      # Injects a key transformation function
+      # Inject a key transformation function
+      #
       # @param [#call,nil] proc
       # @param [#call,nil] block
+      #
       # @return [Schema]
+      #
+      # @api public
       def with_key_transform(proc = nil, &block)
         fn = proc || block
 
-        if fn.nil?
-          raise ArgumentError, "a block or callable argument is required"
-        end
+        raise ArgumentError, "a block or callable argument is required" if fn.nil?
 
         handle = Dry::Types::FnContainer.register(fn)
         with(key_transform_fn: handle)
       end
 
       # Whether the schema transforms input keys
+      #
       # @return [Boolean]
+      #
       # @api public
-      def trasform_keys?
+      def transform_keys?
         !options[:key_transform_fn].nil?
       end
 
@@ -164,10 +201,13 @@ module Dry
       #   @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]
+      #
+      # @api public
       def schema(keys_or_map)
         if keys_or_map.is_a?(::Array)
           new_keys = keys_or_map
@@ -182,6 +222,8 @@ module Dry
       # Iterate over each key type
       #
       # @return [Array<Dry::Types::Schema::Key>,Enumerator]
+      #
+      # @api public
       def each(&block)
         keys.each(&block)
       end
@@ -189,12 +231,16 @@ module Dry
       # Whether the schema has the given key
       #
       # @param [Symbol] name Key name
+      #
       # @return [Boolean]
+      #
+      # @api public
       def key?(name)
         name_key_map.key?(name)
       end
 
-      # Fetch key type by a key name.
+      # Fetch key type by a key name
+      #
       # Behaves as ::Hash#fetch
       #
       # @overload key(name, fallback = Undefined)
@@ -206,6 +252,8 @@ module Dry
       #   @param [Symbol] name Key name
       #   @param [Proc] block Fallback block, runs if key is missing
       #   @return [Dry::Types::Schema::Key,Object] key type or block value if key is not in schema
+      #
+      # @api public
       def key(name, fallback = Undefined, &block)
         if Undefined.equal?(fallback)
           name_key_map.fetch(name, &block)
@@ -215,83 +263,145 @@ module Dry
       end
 
       # @return [Boolean]
+      #
+      # @api public
       def constrained?
         true
       end
 
+      # @return [Lax]
+      #
+      # @api public
+      def lax
+        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
+      #
       # @return [Dry::Types::Schema]
+      #
       # @api private
       def merge_keys(*keys)
-        keys.
-          flatten(1).
-          each_with_object({}) { |key, merged| merged[key.name] = key }.
-          values
+        keys
+          .flatten(1)
+          .each_with_object({}) { |key, merged| merged[key.name] = key }
+          .values
       end
 
-      def resolve(hash, options = EMPTY_HASH, &block)
+      # Validate and coerce a hash. Raise an exception on any error
+      #
+      # @api private
+      #
+      # @return [Hash]
+      def resolve_unsafe(hash, options = EMPTY_HASH)
         result = {}
 
         hash.each do |key, value|
-          k = transform_key.(key)
-
-          if name_key_map.key?(k)
-            result[k] = yield(name_key_map[k], value)
+          k = @transform_key.(key)
+          type = @name_key_map[k]
+
+          if type
+            begin
+              result[k] = type.call_unsafe(value)
+            rescue ConstraintError => e
+              raise SchemaError.new(type.name, value, e.result)
+            rescue CoercionError => e
+              raise SchemaError.new(type.name, value, e.message)
+            end
           elsif strict?
-            raise UnknownKeysError.new(*unexpected_keys(hash.keys))
+            raise unexpected_keys(hash.keys)
           end
         end
 
-        if result.size < keys.size
-          resolve_missing_keys(result, options, &block)
+        resolve_missing_keys(result, options) if result.size < keys.size
+
+        result
+      end
+
+      # Validate and coerce a hash. Call a block and halt on any error
+      #
+      # @api private
+      #
+      # @return [Hash]
+      def resolve_safe(hash, options = EMPTY_HASH, &block)
+        result = {}
+
+        hash.each do |key, value|
+          k = @transform_key.(key)
+          type = @name_key_map[k]
+
+          if type
+            result[k] = type.call_safe(value, &block)
+          elsif strict?
+            yield
+          end
         end
 
+        resolve_missing_keys(result, options, &block) if result.size < keys.size
+
         result
       end
 
-      def resolve_missing_keys(result, options)
+      # Try to add missing keys to the hash
+      #
+      # @api private
+      def resolve_missing_keys(hash, options)
         skip_missing = options.fetch(:skip_missing, false)
         resolve_defaults = options.fetch(:resolve_defaults, true)
 
         keys.each do |key|
-          next if result.key?(key.name)
+          next if hash.key?(key.name)
 
           if key.default? && resolve_defaults
-            result[key.name] = yield(key, Undefined)
+            hash[key.name] = key.call_unsafe(Undefined)
           elsif key.required? && !skip_missing
-            raise MissingKeyError, key.name
+            if block_given?
+              return yield
+            else
+              raise missing_key(key.name)
+            end
           end
         end
       end
 
-      # @param keys [Array<Symbol>]
-      # @return [Array<Symbol>]
-      def unexpected_keys(keys)
-        keys.map(&transform_key) - name_key_map.keys
-      end
-
-      # @param [Hash] hash
-      # @return [Hash{Symbol => Object}]
-      def try_coerce(hash)
-        resolve(hash) do |key, value|
-          yield(key, key.try(value))
-        end
+      # @param hash_keys [Array<Symbol>]
+      #
+      # @return [UnknownKeysError]
+      #
+      # @api private
+      def unexpected_keys(hash_keys)
+        extra_keys = hash_keys.map(&transform_key) - name_key_map.keys
+        UnknownKeysError.new(extra_keys)
       end
 
-      # @param [Hash] hash
-      # @return [Hash{Symbol => Object}]
-      def coerce(hash, options = EMPTY_HASH)
-        resolve(hash, options) do |key, value|
-          begin
-            key.(value)
-          rescue ConstraintError => e
-            raise SchemaError.new(key.name, value, e.result)
-          rescue TypeError, ArgumentError => e
-            raise SchemaError.new(key.name, value, e.message)
-          end
-        end
+      # @return [MissingKeyError]
+      #
+      # @api private
+      def missing_key(key)
+        MissingKeyError.new(key)
       end
     end
   end

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

@@ -1,102 +1,164 @@
-RSpec.shared_examples_for 'Dry::Types::Nominal without primitive' do
+# frozen_string_literal: true
+
+RSpec.shared_examples_for "Dry::Types::Nominal without primitive" do
   def be_boolean
-    satisfy { |x| x == true || x == false  }
+    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
-      if type.class.name.start_with?('Dry::Types')
-        expect(type.to_s).to start_with('#<Dry::Types')
-      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")
+    end
+  end
+
+  describe "#to_proc" do
+    subject(:callable) { type.to_proc }
+
+    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
-      derived = type.with(meta: {immutable_test: 1})
+      derived = type.meta(immutable_test: 1)
       expect(derived.meta).to be_frozen
-      expect(derived.meta).to eql({immutable_test: 1})
+      expect(derived.meta).to eql(immutable_test: 1)
       expect(type.meta).not_to have_key :immutable_test
     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)
     end
   end
 end
+
+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
+      Array(inputs).each do |input|
+        expect(type.(input) { fallback }).to be(fallback)
+      end
+    end
+
+    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
+      Array(inputs).each do |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