dry-schema 1.3.4 → 1.5.0

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019 dry-rb team
+Copyright (c) 2015-2020 dry-rb team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.md

@@ -1,15 +1,15 @@
 [gem]: https://rubygems.org/gems/dry-schema
-[travis]: https://travis-ci.com/dry-rb/dry-schema
-[codeclimate]: https://codeclimate.com/github/dry-rb/dry-schema
+[actions]: https://github.com/dry-rb/dry-schema/actions
+[codacy]: https://www.codacy.com/gh/dry-rb/dry-schema
 [chat]: https://dry-rb.zulipchat.com
 [inchpages]: http://inch-ci.org/github/dry-rb/dry-schema
 
 # 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]
-[![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]
+[![CI Status](https://github.com/dry-rb/dry-schema/workflows/ci/badge.svg)][actions]
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/961f5c776f1d49218b2cede3745e059c)][codacy]
+[![Codacy Badge](https://api.codacy.com/project/badge/Coverage/961f5c776f1d49218b2cede3745e059c)][codacy]
 [![Inline docs](http://inch-ci.org/github/dry-rb/dry-schema.svg?branch=master)][inchpages]
 
 ## Links
@@ -19,7 +19,7 @@
 
 ## Supported Ruby versions
 
-This library officially supports following Ruby versions:
+This library officially supports the following Ruby versions:
 
 * MRI >= `2.4`
 * jruby >= `9.2`

data/config/errors.yml

@@ -3,6 +3,8 @@ en:
     or: "or"
 
     errors:
+      unexpected_key: "is not allowed"
+
       array?: "must be an array"
 
       empty?: "must be empty"
@@ -101,5 +103,7 @@ en:
           default: "must be %{size} bytes long"
           range: "must be within %{size_left} - %{size_right} bytes long"
 
+      uuid_v4?: "is not a valid UUID"
+
       not:
         empty?: "cannot be empty"

data/dry-schema.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# this file is managed by dry-rb/devtools project
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dry/schema/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dry-schema'
+  spec.authors       = ["Piotr Solnica"]
+  spec.email         = ["piotr.solnica@gmail.com"]
+  spec.license       = 'MIT'
+  spec.version       = Dry::Schema::VERSION.dup
+
+  spec.summary       = "Coercion and validation for data structures"
+  spec.description   = <<~TEXT
+    dry-schema provides a DSL for defining schemas with keys and rules that should be applied to
+    values. It supports coercion, input sanitization, custom types and localized error messages
+    (with or without I18n gem). It's also used as the schema engine in dry-validation.
+  TEXT
+  spec.homepage      = 'https://dry-rb.org/gems/dry-schema'
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "dry-schema.gemspec", "lib/**/*", "config/*.yml"]
+  spec.bindir        = 'bin'
+  spec.executables   = []
+  spec.require_paths = ['lib']
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['changelog_uri']     = 'https://github.com/dry-rb/dry-schema/blob/master/CHANGELOG.md'
+  spec.metadata['source_code_uri']   = 'https://github.com/dry-rb/dry-schema'
+  spec.metadata['bug_tracker_uri']   = 'https://github.com/dry-rb/dry-schema/issues'
+
+  spec.required_ruby_version = ">= 2.4.0"
+
+  # to update dependencies edit project.yml
+  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_runtime_dependency "dry-configurable", "~> 0.8", ">= 0.8.3"
+  spec.add_runtime_dependency "dry-core", "~> 0.4"
+  spec.add_runtime_dependency "dry-equalizer", "~> 0.2"
+  spec.add_runtime_dependency "dry-initializer", "~> 3.0"
+  spec.add_runtime_dependency "dry-logic", "~> 1.0"
+  spec.add_runtime_dependency "dry-types", "~> 1.4"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/dry-schema.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-require 'dry/schema'
+require "dry/schema"

data/lib/dry/schema.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require 'dry/core/extensions'
+require "dry/core/extensions"
 
-require 'dry/schema/constants'
-require 'dry/schema/dsl'
-require 'dry/schema/params'
-require 'dry/schema/json'
+require "dry/schema/config"
+require "dry/schema/constants"
+require "dry/schema/dsl"
+require "dry/schema/params"
+require "dry/schema/json"
 
 module Dry
   # Main interface
@@ -14,6 +15,18 @@ module Dry
   module Schema
     extend Dry::Core::Extensions
 
+    # Configuration
+    #
+    # @example
+    #   Dry::Schema.config.messages.backend = :i18n
+    #
+    # @return [Config]
+    #
+    # @api public
+    def self.config
+      @config ||= Config.new
+    end
+
     # Define a schema
     #
     # @example
@@ -30,7 +43,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
@@ -74,4 +87,4 @@ module Dry
   end
 end
 
-require 'dry/schema/extensions'
+require "dry/schema/extensions"

data/lib/dry/schema/compiler.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'dry/logic/rule_compiler'
-require 'dry/schema/namespaced_rule'
-require 'dry/schema/predicate_registry'
+require "dry/logic/rule_compiler"
+require "dry/schema/namespaced_rule"
+require "dry/schema/predicate_registry"
 
 module Dry
   module Schema
@@ -35,7 +35,7 @@ module Dry
       # @return [NamespacedRule]
       #
       # @api private
-      def visit_namespace(node, opts = EMPTY_HASH)
+      def visit_namespace(node, _opts = EMPTY_HASH)
         namespace, rest = node
         NamespacedRule.new(namespace, visit(rest))
       end

data/lib/dry/schema/config.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
-require 'dry/configurable'
+require "dry/equalizer"
+require "dry/configurable"
 
-require 'dry/schema/constants'
-require 'dry/schema/predicate_registry'
-require 'dry/schema/type_container'
+require "dry/schema/constants"
+require "dry/schema/predicate_registry"
+require "dry/schema/type_container"
 
 module Dry
   module Schema
@@ -51,6 +51,15 @@ module Dry
         setting(:default_locale, nil)
       end
 
+      # @!method validate_keys
+      #
+      # On/off switch for key validator
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      setting(:validate_keys, false)
+
       # @api private
       def respond_to_missing?(meth, include_private = false)
         super || config.respond_to?(meth, include_private)
@@ -58,7 +67,7 @@ module Dry
 
       # @api private
       def inspect
-        "#<#{self.class} #{to_h.map { |k,v| ["#{k}=", v.inspect] }.map(&:join).join(' ')}>"
+        "#<#{self.class} #{to_h.map { |k, v| ["#{k}=", v.inspect] }.map(&:join).join(" ")}>"
       end
 
       private

data/lib/dry/schema/constants.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'pathname'
-require 'dry/core/constants'
+require "pathname"
+require "dry/core/constants"
 
 module Dry
   # Common constants used across the library
@@ -10,15 +10,24 @@ module Dry
   module Schema
     include Core::Constants
 
-    LIST_SEPARATOR = ', '
-    QUESTION_MARK = '?'
-    DOT = '.'
+    LIST_SEPARATOR = ", "
+    QUESTION_MARK = "?"
+    DOT = "."
+
+    # core processor steps in the default execution order
+    STEPS_IN_ORDER = %i[
+      key_validator
+      key_coercer
+      filter_schema
+      value_coercer
+      rule_applier
+    ].freeze
 
     # Path to the default set of localized messages bundled within the gem
-    DEFAULT_MESSAGES_PATH = Pathname(__dir__).join('../../../config/errors.yml').realpath.freeze
+    DEFAULT_MESSAGES_PATH = Pathname(__dir__).join("../../../config/errors.yml").realpath.freeze
 
     # Default namespace used for localized messages in YAML files
-    DEFAULT_MESSAGES_ROOT = 'dry_schema'
+    DEFAULT_MESSAGES_ROOT = "dry_schema"
 
     # An error raised when DSL is used in an incorrect way
     InvalidSchemaError = Class.new(StandardError)
@@ -26,10 +35,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

@@ -1,18 +1,22 @@
 # frozen_string_literal: true
 
-require 'dry/initializer'
-
-require 'dry/schema/constants'
-require 'dry/schema/config'
-require 'dry/schema/compiler'
-require 'dry/schema/types'
-require 'dry/schema/macros'
-
-require 'dry/schema/processor'
-require 'dry/schema/key_map'
-require 'dry/schema/key_coercer'
-require 'dry/schema/value_coercer'
-require 'dry/schema/rule_applier'
+require "dry/initializer"
+
+require "dry/schema"
+require "dry/schema/constants"
+require "dry/schema/path"
+require "dry/schema/config"
+require "dry/schema/compiler"
+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/key_validator"
+require "dry/schema/value_coercer"
+require "dry/schema/rule_applier"
 
 module Dry
   module Schema
@@ -50,8 +54,6 @@ module Dry
 
       extend Dry::Initializer
 
-      include ::Dry::Equalizer(:options)
-
       # @return [Compiler] The rule compiler object
       option :compiler, default: -> { Compiler.new }
 
@@ -64,18 +66,24 @@ 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 }
+      option :config, optional: true, default: proc { default_config }
+
+      # @return [ProcessorSteps] Steps for the processor
+      option :steps, default: proc { ProcessorSteps.new }
+
+      # @return [Path, Array] Path under which the schema is defined
+      option :path, -> *args { Path[*args] if args.any? }, default: proc { EMPTY_ARRAY }
 
       # 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
@@ -169,7 +177,7 @@ module Dry
       def key(name, macro:, &block)
         raise ArgumentError, "Key +#{name}+ is not a symbol" unless name.is_a?(::Symbol)
 
-        set_type(name, Types::Any)
+        set_type(name, Types::Any.meta(default: true))
 
         macro = macro.new(
           name: name,
@@ -189,11 +197,31 @@ module Dry
       #
       # @api private
       def call
-        steps = [key_coercer]
-        steps << filter_schema.rule_applier if filter_rules?
-        steps << value_coercer << rule_applier
+        all_steps = parents.map(&:steps) + [steps]
+
+        result_steps = all_steps.inject { |result, steps| result.merge(steps) }
+
+        result_steps[:key_validator] = key_validator if config.validate_keys
+        result_steps[:key_coercer] = key_coercer
+        result_steps[:value_coercer] = value_coercer
+        result_steps[:rule_applier] = rule_applier
+        result_steps[:filter_schema] = filter_schema.rule_applier if filter_rules?
 
-        processor_type.new(schema_dsl: self, steps: steps)
+        processor_type.new(schema_dsl: self, steps: result_steps)
+      end
+
+      # Merge with another dsl
+      #
+      # @return [DSL]
+      #
+      # @api private
+      def merge(other)
+        new(
+          parent: parents + other.parents,
+          macros: macros + other.macros,
+          types: types.merge(other.types),
+          steps: steps.merge(other.steps)
+        )
       end
 
       # Cast this DSL into a rule object
@@ -212,7 +240,46 @@ module Dry
       #
       # @api public
       def array
-        -> member_type { type_registry['array'].of(resolve_type(member_type)) }
+        -> 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
@@ -221,8 +288,9 @@ module Dry
       #
       # @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 +298,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
@@ -244,11 +312,20 @@ module Dry
       # @api private
       def set_type(name, spec)
         type = resolve_type(spec)
-        meta = { required: false, maybe: type.optional? }
+        meta = {required: false, maybe: type.optional?}
 
         types[name] = type.meta(meta)
       end
 
+      # Check if a custom type was set under provided key name
+      #
+      # @return [Bool]
+      #
+      # @api private
+      def custom_type?(name)
+        !types[name].meta[:default].equal?(true)
+      end
+
       # Resolve type object from the provided spec
       #
       # @param [Symbol, Array<Symbol>, Dry::Types::Type] spec
@@ -276,14 +353,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 +404,17 @@ module Dry
       private
 
       # @api private
-      def parent_filter_schema
-        return unless parent
+      def parent_filter_schemas
+        parents.select(&:filter_rules?).map(&:filter_schema)
+      end
 
-        parent.filter_schema if parent.filter_rules?
+      # Build a key validator
+      #
+      # @return [KeyValidator]
+      #
+      # @api private
+      def key_validator
+        KeyValidator.new(key_map: key_map + parent_key_map)
       end
 
       # Build a key coercer
@@ -366,13 +454,19 @@ module Dry
 
       # Build a key spec needed by the key map
       #
+      # TODO: we need a key-map compiler using Types AST
+      #
       # @api private
       def key_spec(name, type)
         if type.respond_to?(:keys)
-          { name => key_map(type.name_key_map) }
+          {name => key_map(type.name_key_map)}
         elsif type.respond_to?(:member)
           kv = key_spec(name, type.member)
           kv.equal?(name) ? name : kv.flatten(1)
+        elsif type.meta[:maybe] && type.respond_to?(:right)
+          key_spec(name, type.right)
+        elsif type.respond_to?(:type)
+          key_spec(name, type.type)
         else
           name
         end
@@ -380,12 +474,24 @@ 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
+
+      # @api private
+      def default_config
+        parents.each_cons(2) do |left, right|
+          unless left.config == right.config
+            raise ArgumentError,
+                  "Parent configs differ, left=#{left.inspect}, right=#{right.inspect}"
+          end
+        end
+
+        (parent || Schema).config.dup
       end
     end
   end