dry-schema 1.3.2 → 1.4.2

data/README.md

@@ -1,5 +1,5 @@
 [gem]: https://rubygems.org/gems/dry-schema
-[travis]: https://travis-ci.com/dry-rb/dry-schema
+[actions]: https://github.com/dry-rb/dry-schema/actions
 [codeclimate]: https://codeclimate.com/github/dry-rb/dry-schema
 [chat]: https://dry-rb.zulipchat.com
 [inchpages]: http://inch-ci.org/github/dry-rb/dry-schema
@@ -7,7 +7,7 @@
 # dry-schema [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://badge.fury.io/rb/dry-schema.svg)][gem]
-[![Build Status](https://travis-ci.com/dry-rb/dry-schema.svg?branch=master)][travis]
+[![CI Status](https://github.com/dry-rb/dry-schema/workflows/ci/badge.svg)][actions]
 [![Code Climate](https://codeclimate.com/github/dry-rb/dry-schema/badges/gpa.svg)][codeclimate]
 [![Test Coverage](https://codeclimate.com/github/dry-rb/dry-schema/badges/coverage.svg)][codeclimate]
 [![Inline docs](http://inch-ci.org/github/dry-rb/dry-schema.svg?branch=master)][inchpages]

data/lib/dry/schema.rb

@@ -30,7 +30,7 @@ module Dry
     #
     # @api public
     def self.define(**options, &block)
-      DSL.new(options, &block).call
+      DSL.new(**options, &block).call
     end
 
     # Define a schema suitable for HTTP params

data/lib/dry/schema/constants.rb

@@ -26,10 +26,11 @@ module Dry
     # An error raised when a localized message cannot be found
     MissingMessageError = Class.new(StandardError) do
       # @api private
-      def initialize(path)
+      def initialize(path, paths = [])
         *rest, rule = path
         super(<<~STR)
-          Message template for #{rule.inspect} under #{rest.join(DOT).inspect} was not found
+          Message template for #{rule.inspect} under #{rest.join(DOT).inspect} was not found. Searched in:
+          #{paths.map { |string| "\"#{string}\"" }.join("\n")}
         STR
       end
     end

data/lib/dry/schema/dsl.rb

@@ -9,6 +9,7 @@ require 'dry/schema/types'
 require 'dry/schema/macros'
 
 require 'dry/schema/processor'
+require 'dry/schema/processor_steps'
 require 'dry/schema/key_map'
 require 'dry/schema/key_coercer'
 require 'dry/schema/value_coercer'
@@ -50,8 +51,6 @@ module Dry
 
       extend Dry::Initializer
 
-      include ::Dry::Equalizer(:options)
-
       # @return [Compiler] The rule compiler object
       option :compiler, default: -> { Compiler.new }
 
@@ -64,18 +63,21 @@ module Dry
       # @return [Compiler] A key=>type map defined within the DSL
       option :types, default: -> { EMPTY_HASH.dup }
 
-      # @return [DSL] An optional parent DSL object that will be used to merge keys and rules
-      option :parent, optional: true
+      # @return [Array] Optional parent DSL objects, that will be used to merge keys and rules
+      option :parent, Types::Coercible::Array, default: -> { EMPTY_ARRAY.dup }, as: :parents
 
       # @return [Config] Configuration object exposed via `#configure` method
       option :config, optional: true, default: proc { parent ? parent.config.dup : Config.new }
 
+      # @return [ProcessorSteps] Steps for the processor
+      option :steps, default: proc { parent ? parent.steps.dup : ProcessorSteps.new }
+
       # Build a new DSL object and evaluate provided block
       #
       # @param [Hash] options
       # @option options [Class] :processor The processor type (`Params`, `JSON` or a custom sub-class)
       # @option options [Compiler] :compiler An instance of a rule compiler (must be compatible with `Schema::Compiler`) (optional)
-      # @option options [DSL] :parent An instance of the parent DSL (optional)
+      # @option options [Array[DSL]] :parent One or more instances of the parent DSL (optional)
       # @option options [Config] :config A configuration object (optional)
       #
       # @see Schema.define
@@ -189,9 +191,10 @@ module Dry
       #
       # @api private
       def call
-        steps = [key_coercer]
-        steps << filter_schema.rule_applier if filter_rules?
-        steps << value_coercer << rule_applier
+        steps[:key_coercer] = key_coercer
+        steps[:value_coercer] = value_coercer
+        steps[:rule_applier] = rule_applier
+        steps[:filter_schema] = filter_schema.rule_applier if filter_rules?
 
         processor_type.new(schema_dsl: self, steps: steps)
       end
@@ -215,14 +218,54 @@ module Dry
         -> member_type { type_registry['array'].of(resolve_type(member_type)) }
       end
 
+      # Method allows steps injection to the processor
+      #
+      # @example
+      #   before(:rule_applier) do |input|
+      #     input.compact
+      #   end
+      #
+      # @return [DSL]
+      #
+      # @api public
+      def before(key, &block)
+        steps.before(key, &block)
+        self
+      end
+
+      # Method allows steps injection to the processor
+      #
+      # @example
+      #   after(:rule_applier) do |input|
+      #     input.compact
+      #   end
+      #
+      # @return [DSL]
+      #
+      # @api public
+      def after(key, &block)
+        steps.after(key, &block)
+        self
+      end
+
+      # The parent (last from parents) which is used for copying non mergeable configuration
+      #
+      # @return DSL
+      #
+      # @api public
+      def parent
+        @parent ||= parents.last
+      end
+
       # Return type schema used by the value coercer
       #
       # @return [Dry::Types::Safe]
       #
       # @api private
       def type_schema
-        schema = type_registry['hash'].schema(types).lax
-        parent ? parent.type_schema.schema(schema.to_a) : schema
+        our_schema = type_registry['hash'].schema(types).lax
+        schemas = [*parents.map(&:type_schema), our_schema]
+        schemas.inject { |result, schema| result.schema(schema.to_a) }
       end
 
       # Return a new DSL instance using the same processor type
@@ -230,8 +273,8 @@ module Dry
       # @return [Dry::Types::Safe]
       #
       # @api private
-      def new(options = EMPTY_HASH, &block)
-        self.class.new(options.merge(processor_type: processor_type, config: config), &block)
+      def new(**options, &block)
+        self.class.new(**options, processor_type: processor_type, config: config, &block)
       end
 
       # Set a type for the given key name
@@ -276,14 +319,18 @@ module Dry
       #
       # @api private
       def filter_schema_dsl
-        @filter_schema_dsl ||= new(parent: parent_filter_schema)
+        @filter_schema_dsl ||= new(parent: parent_filter_schemas)
       end
 
       # Check if any filter rules were defined
       #
       # @api private
       def filter_rules?
-        (instance_variable_defined?('@filter_schema_dsl') && !filter_schema_dsl.macros.empty?) || parent&.filter_rules?
+        if instance_variable_defined?('@filter_schema_dsl') && !filter_schema_dsl.macros.empty?
+          return true
+        end
+
+        parents.any?(&:filter_rules?)
       end
 
       protected
@@ -323,10 +370,8 @@ module Dry
       private
 
       # @api private
-      def parent_filter_schema
-        return unless parent
-
-        parent.filter_schema if parent.filter_rules?
+      def parent_filter_schemas
+        parents.select(&:filter_rules?).map(&:filter_schema)
       end
 
       # Build a key coercer
@@ -380,12 +425,12 @@ module Dry
 
       # @api private
       def parent_rules
-        parent&.rules || EMPTY_HASH
+        parents.reduce({}) { |rules, parent| rules.merge(parent.rules) }
       end
 
       # @api private
       def parent_key_map
-        parent&.key_map || EMPTY_ARRAY
+        parents.reduce([]) { |key_map, parent| parent.key_map + key_map }
       end
     end
   end

data/lib/dry/schema/extensions/hints/message_compiler_methods.rb

@@ -19,7 +19,7 @@ module Dry
           attr_reader :hints
 
           # @api private
-          def initialize(*args)
+          def initialize(*, **)
             super
             @hints = @options.fetch(:hints, true)
           end

data/lib/dry/schema/key.rb

@@ -27,8 +27,8 @@ module Dry
       end
 
       # @api private
-      def self.new(*args)
-        fetch_or_store(*args) { super }
+      def self.new(*args, **kwargs)
+        fetch_or_store(args, kwargs) { super }
       end
 
       # @api private
@@ -65,8 +65,8 @@ module Dry
       end
 
       # @api private
-      def new(new_opts = EMPTY_HASH)
-        self.class.new(id, { name: name, coercer: coercer }.merge(new_opts))
+      def new(**new_opts)
+        self.class.new(id, name: name, coercer: coercer, **new_opts)
       end
 
       # @api private

data/lib/dry/schema/macros/core.rb

@@ -28,8 +28,8 @@ module Dry
         option :schema_dsl, optional: true
 
         # @api private
-        def new(options = EMPTY_HASH)
-          self.class.new({ name: name, compiler: compiler, schema_dsl: schema_dsl }.merge(options))
+        def new(**options)
+          self.class.new(name: name, compiler: compiler, schema_dsl: schema_dsl, **options)
         end
 
         # @api private

data/lib/dry/schema/macros/dsl.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'dry/logic/operators'
+require 'dry/types/predicate_inferrer'
+require 'dry/types/primitive_inferrer'
 
 require 'dry/schema/macros/core'
 
@@ -26,7 +28,13 @@ module Dry
         #   PredicateInferrer is used to infer predicate type-check from a type spec
         #   @return [PredicateInferrer]
         #   @api private
-        option :predicate_inferrer, default: proc { PredicateInferrer.new(compiler.predicates) }
+        option :predicate_inferrer, default: proc { ::Dry::Types::PredicateInferrer.new(compiler.predicates) }
+
+        # @!attribute [r] primitive_inferrer
+        #   PrimitiveInferrer used to get a list of primitive classes from configured type
+        #   @return [PrimitiveInferrer]
+        #   @api private
+        option :primitive_inferrer, default: proc { ::Dry::Types::PrimitiveInferrer.new }
 
         # @overload value(*predicates, **predicate_opts)
         #   Set predicates without and with arguments
@@ -49,11 +57,12 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def value(*predicates, **opts, &block)
+        def value(*predicates, &block)
           append_macro(Macros::Value) do |macro|
-            macro.call(*predicates, **opts, &block)
+            macro.call(*predicates, &block)
           end
         end
+        ruby2_keywords :value if respond_to?(:ruby2_keywords, true)
 
         # Prepends `:filled?` predicate
         #
@@ -66,11 +75,12 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def filled(*args, **opts, &block)
+        def filled(*args, &block)
           append_macro(Macros::Filled) do |macro|
-            macro.call(*args, **opts, &block)
+            macro.call(*args, &block)
           end
         end
+        ruby2_keywords :filled if respond_to?(:ruby2_keywords, true)
 
         # Specify a nested hash without enforced `hash?` type-check
         #
@@ -91,6 +101,7 @@ module Dry
             macro.call(*args, &block)
           end
         end
+        ruby2_keywords :schema if respond_to?(:ruby2_keywords, true)
 
         # Specify a nested hash with enforced `hash?` type-check
         #
@@ -105,6 +116,7 @@ module Dry
             macro.call(*args, &block)
           end
         end
+        ruby2_keywords :hash if respond_to?(:ruby2_keywords, true)
 
         # Specify predicates that should be applied to each element of an array
         #
@@ -128,6 +140,7 @@ module Dry
             macro.value(*args, &block)
           end
         end
+        ruby2_keywords :each if respond_to?(:ruby2_keywords, true)
 
         # Like `each` but sets `array?` type-check
         #
@@ -147,6 +160,7 @@ module Dry
             macro.value(*args, &block)
           end
         end
+        ruby2_keywords :array if respond_to?(:ruby2_keywords, true)
 
         # Set type spec
         #
@@ -192,9 +206,7 @@ module Dry
           predicates = Array(type_spec ? args[1..-1] : args)
 
           if type_spec
-            resolved_type = schema_dsl.resolve_type(
-              nullable && !type_spec.is_a?(::Array) ? [:nil, type_spec] : type_spec
-            )
+            resolved_type = resolve_type(type_spec, nullable)
 
             type(resolved_type) if set_type
 
@@ -207,6 +219,17 @@ module Dry
 
           yield(*predicates, type_spec: type_spec)
         end
+
+        # @api private
+        def resolve_type(type_spec, nullable)
+          resolved = schema_dsl.resolve_type(type_spec)
+
+          if type_spec.is_a?(::Array) || !nullable || resolved.optional?
+            resolved
+          else
+            schema_dsl.resolve_type([:nil, resolved])
+          end
+        end
       end
     end
   end

data/lib/dry/schema/macros/filled.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/schema/primitive_inferrer'
 require 'dry/schema/macros/value'
 
 module Dry
@@ -10,12 +9,6 @@ module Dry
       #
       # @api private
       class Filled < Value
-        # @!attribute [r] primitive_inferrer
-        #   PrimitiveInferrer used to get a list of primitive classes from configured type
-        #   @return [PrimitiveInferrer]
-        #   @api private
-        option :primitive_inferrer, default: proc { PrimitiveInferrer.new }
-
         # @api private
         def call(*predicates, **opts, &block)
           ensure_valid_predicates(predicates)

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/schema/predicate_inferrer'
 require 'dry/schema/processor'
 require 'dry/schema/macros/dsl'
 require 'dry/schema/constants'
@@ -31,6 +30,7 @@ module Dry
           (filter_schema_dsl[name] || filter_schema_dsl.optional(name)).value(*args, &block)
           self
         end
+        ruby2_keywords(:filter) if respond_to?(:ruby2_keywords, true)
 
         # @overload value(type_spec, *predicates, **predicate_opts)
         #   Set type specification and predicates
@@ -88,7 +88,7 @@ module Dry
         def maybe(*args, **opts, &block)
           extract_type_spec(*args, nullable: true) do |*predicates, type_spec:|
             append_macro(Macros::Maybe) do |macro|
-              macro.call(*predicates, **opts, &block)
+              macro.call(*predicates, type_spec: type_spec, **opts, &block)
             end
           end
         end

data/lib/dry/schema/macros/schema.rb

@@ -28,8 +28,8 @@ module Dry
           definition = schema_dsl.new(&block)
           schema = definition.call
           type_schema =
-            if array?
-              parent_type.of(definition.type_schema)
+            if array_type?(parent_type)
+              build_array_type(parent_type, definition.type_schema)
             elsif redefined_schema?(args)
               parent_type.schema(definition.types)
             else
@@ -56,11 +56,6 @@ module Dry
           parent_type.optional?
         end
 
-        # @api private
-        def array?
-          parent_type.respond_to?(:of)
-        end
-
         # @api private
         def schema?
           parent_type.respond_to?(:schema)

data/lib/dry/schema/macros/value.rb

@@ -17,8 +17,8 @@ module Dry
             current_type = schema_dsl.types[name]
 
             updated_type =
-              if current_type.respond_to?(:of)
-                current_type.of(schema.type_schema)
+              if array_type?(current_type)
+                build_array_type(current_type, schema.type_schema)
               else
                 schema.type_schema
               end
@@ -39,6 +39,25 @@ module Dry
           self
         end
 
+        # @api private
+        def array_type?(type)
+          primitive_inferrer[type].eql?([::Array])
+        end
+
+        # @api private
+        def build_array_type(array_type, member)
+          if array_type.respond_to?(:of)
+            array_type.of(member)
+          else
+            raise ArgumentError, <<~ERROR.split("\n").join(' ')
+              Cannot define schema for a nominal array type.
+              Array types must be instances of Dry::Types::Array,
+              usually constructed with Types::Constructor(Array) { ... } or
+              Dry::Types['array'].constructor { ... }
+            ERROR
+          end
+        end
+
         # @api private
         def respond_to_missing?(meth, include_private = false)
           super || meth.to_s.end_with?(QUESTION_MARK)