dry-schema 1.9.2 → 1.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c27dabeb33b1644739f90d7bbac22dfe85ae79d742da8376cad64bdfff46c514
-  data.tar.gz: 5b4df5b8215933c70fd3c04fd3a8cd74c0ff7bdfe4919110f95753348ce28726
+  metadata.gz: 0e0f30051a5014afc7cf0dc8f66f23a20f05e83dd3b2a970491d85d84e5be988
+  data.tar.gz: 771b790fd369f36abf86367a95afaac387825df4b041bdc325c02f7f41cd3487
 SHA512:
-  metadata.gz: 9111228ae652344f54044d93fd7516d67cdefa0789587b786d58291d40f9c61c009207c5b3ef68d7302e8e889a125e51fbd4bfa3a5ee6b8b2629a2e06cf7a538
-  data.tar.gz: bc1701018a9c35fb618c92a50fb4d68f24957f3d22431e343457dba65645d6476a5c7378620fe934b8520cfd20d62a2d2de1ac5c04af1f0130dfba5de86cb2f9
+  metadata.gz: 12759b86883bd94e85480124539c44a3280491935a86addacd02c799696cce5d5e1cec54238b17d89c05cbe704e2394ac4749c9349e9f8e1bbe6ed92f344af73
+  data.tar.gz: 57b2a77a57ef8587a3a520eeecc7cc3dd5d766a92ba5096ed2306c0e466ee0c9580e7550c3ef475e88eb61a58ce7c92de3860442e29455f5590ccfa0bd7b5eda

data/CHANGELOG.md

@@ -1,5 +1,58 @@
 <!--- DO NOT EDIT THIS FILE - IT'S AUTOMATICALLY GENERATED VIA DEVTOOLS --->
 
+## 1.10.2 2022-08-23
+
+
+### Fixed
+
+- Fix value coercion for composed schemas (via #421) (@robhanlon22)
+
+
+[Compare v1.10.1...v1.10.2](https://github.com/dry-rb/dry-schema/compare/v1.10.1...v1.10.2)
+
+## 1.10.1 2022-08-22
+
+
+### Changed
+
+- Reverted zeitwerk-related changes that were included in 1.10.0 by an accident (@solnic)
+
+[Compare v1.10.0...v1.10.1](https://github.com/dry-rb/dry-schema/compare/v1.10.0...v1.10.1)
+
+## 1.10.0 2022-08-16
+
+
+### Added
+
+- Allow nested `filled` and `value` macro usage (via #412) (@robhanlon22)
+- Support for more complex scenarios when composing schemas (via #420) (@robhanlon22)
+
+### Fixed
+
+- Fix `or` messages for complex schemas (via #413) (@robhanlon22)
+- Using `filled` with a constrained constructor type works as expected (via #416) (@robhanlon22)
+- Fix types and key maps for composed schemas (via #415) (@robhanlon22)
+
+### Changed
+
+- Freeze message hash (fixes #417 via #418) (@solnic)
+
+[Compare v1.9.3...v1.10.0](https://github.com/dry-rb/dry-schema/compare/v1.9.3...v1.10.0)
+
+## 1.9.3 2022-06-23
+
+
+### Added
+
+- Support `anyOf` composition in JSON schema output (@robhanlon22)
+
+### Fixed
+
+- Allow composition of multiple ors (issue #307 fixed via #409) (@robhanlon22)
+
+
+[Compare v1.9.2...v1.9.3](https://github.com/dry-rb/dry-schema/compare/v1.9.2...v1.9.3)
+
 ## 1.9.2 2022-05-28
 
 

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2021 dry-rb team
+Copyright (c) 2015-2022 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/lib/dry/schema/dsl.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "dry/initializer"
+require "dry/logic"
 
 require "dry/schema/constants"
 require "dry/schema/path"
@@ -16,6 +17,7 @@ require "dry/schema/key_coercer"
 require "dry/schema/key_validator"
 require "dry/schema/value_coercer"
 require "dry/schema/rule_applier"
+require "dry/schema/types_merger"
 
 module Dry
   module Schema
@@ -286,13 +288,20 @@ module Dry
 
       # Return type schema used by the value coercer
       #
-      # @return [Dry::Types::Safe]
+      # @return [Dry::Types::Lax]
       #
       # @api private
       def type_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) }
+        strict_type_schema.lax
+      end
+
+      # Return type schema used when composing subschemas
+      #
+      # @return [Dry::Types::Schema]
+      #
+      # @api private
+      def strict_type_schema
+        type_registry["hash"].schema(types)
       end
 
       # Return a new DSL instance using the same processor type
@@ -314,9 +323,9 @@ module Dry
       # @api private
       def set_type(name, spec)
         type = resolve_type(spec)
-        meta = {required: false, maybe: type.optional?}
+        meta = {required: true, maybe: type.optional?}
 
-        types[name] = type.meta(meta)
+        @types[name] = type.meta(meta)
       end
 
       # Check if a custom type was set under provided key name
@@ -369,6 +378,18 @@ module Dry
         parents.any?(&:filter_rules?)
       end
 
+      # This DSL's type map merged with any parent type maps
+      #
+      # @api private
+      def types
+        [*parents.map(&:types), @types].reduce(:merge)
+      end
+
+      # @api private
+      def merge_types(op_class, lhs, rhs)
+        types_merger.(op_class, lhs, rhs)
+      end
+
       protected
 
       # Build a rule applier
@@ -495,6 +516,10 @@ module Dry
 
         (parent || Schema).config.dup
       end
+
+      def types_merger
+        @types_merger ||= TypesMerger.new(type_registry)
+      end
     end
   end
 end

data/lib/dry/schema/extensions/json_schema/schema_compiler.rb

@@ -114,6 +114,18 @@ module Dry
           end
         end
 
+        # @api private
+        def visit_or(node, opts = EMPTY_HASH)
+          node.each do |child|
+            c = self.class.new(loose: loose?)
+            c.keys.update(subschema: {})
+            c.visit(child, opts.merge(key: :subschema))
+
+            any_of = (keys[opts[:key]][:anyOf] ||= [])
+            any_of << c.keys[:subschema]
+          end
+        end
+
         # @api private
         def visit_implication(node, opts = EMPTY_HASH)
           node.each do |el|

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

@@ -15,7 +15,7 @@ module Dry
         def value(*args, **opts, &block)
           type(:array)
 
-          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:, type_rule:|
+          extract_type_spec(args, set_type: false) do |*predicates, type_spec:, type_rule:|
             type(schema_dsl.array[type_spec]) if type_spec
 
             is_hash_block = type_spec.equal?(:hash)

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

@@ -58,12 +58,13 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def value(...)
-          append_macro(Macros::Value) do |macro|
-            macro.call(...)
+        def value(*args, **opts, &block)
+          extract_type_spec(args) do |*predicates, type_spec:, type_rule:|
+            append_macro(Macros::Value) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
           end
         end
-        ruby2_keywords :value if respond_to?(:ruby2_keywords, true)
 
         # Prepends `:filled?` predicate
         #
@@ -76,12 +77,13 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def filled(...)
-          append_macro(Macros::Filled) do |macro|
-            macro.call(...)
+        def filled(*args, **opts, &block)
+          extract_type_spec(args) do |*predicates, type_spec:, type_rule:|
+            append_macro(Macros::Filled) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
           end
         end
-        ruby2_keywords :filled if respond_to?(:ruby2_keywords, true)
 
         # Specify a nested hash without enforced `hash?` type-check
         #
@@ -201,7 +203,7 @@ module Dry
 
         # @api private
         # rubocop: disable Metrics/PerceivedComplexity
-        def extract_type_spec(*args, nullable: false, set_type: true)
+        def extract_type_spec(args, nullable: false, set_type: true)
           type_spec = args[0] unless schema_or_predicate?(args[0])
 
           predicates = Array(type_spec ? args[1..] : args)

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

@@ -11,13 +11,15 @@ module Dry
       # @api private
       class Each < DSL
         # @api private
-        def value(*args, **opts)
-          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:, type_rule:|
+        def value(*args, **opts, &block)
+          extract_type_spec(args, set_type: false) do |*predicates, type_spec:, type_rule:|
             if type_spec && !type_spec.is_a?(Dry::Types::Type)
               type(schema_dsl.array[type_spec])
             end
 
-            super(*predicates, type_spec: type_spec, type_rule: type_rule, **opts)
+            append_macro(Macros::Value) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
           end
         end
 

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

@@ -32,49 +32,6 @@ module Dry
         end
         ruby2_keywords(:filter) if respond_to?(:ruby2_keywords, true)
 
-        # @overload value(type_spec, *predicates, **predicate_opts)
-        #   Set type specification and predicates
-        #
-        #   @param [Symbol,Types::Type,Array] type_spec
-        #   @param [Array<Symbol>] predicates
-        #   @param [Hash] predicate_opts
-        #
-        #   @example with a predicate
-        #     required(:name).value(:string, :filled?)
-        #
-        #   @example with a predicate with arguments
-        #     required(:name).value(:string, min_size?: 2)
-        #
-        #   @example with a block
-        #     required(:name).value(:string) { filled? & min_size?(2) }
-        #
-        # @return [Macros::Key]
-        #
-        # @see Macros::DSL#value
-        #
-        # @api public
-        def value(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates, type_spec:, type_rule:|
-            super(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
-          end
-        end
-
-        # Set type specification and predicates for a filled value
-        #
-        # @example
-        #   required(:name).filled(:string)
-        #
-        # @see Macros::Key#value
-        #
-        # @return [Macros::Key]
-        #
-        # @api public
-        def filled(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates, type_spec:, type_rule:|
-            super(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
-          end
-        end
-
         # Set type specification and predicates for a maybe value
         #
         # @example
@@ -86,7 +43,7 @@ module Dry
         #
         # @api public
         def maybe(*args, **opts, &block)
-          extract_type_spec(*args, nullable: true) do |*predicates, type_spec:, type_rule:|
+          extract_type_spec(args, nullable: true) do |*predicates, type_spec:, type_rule:|
             append_macro(Macros::Maybe) do |macro|
               macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
             end

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

@@ -30,13 +30,7 @@ module Dry
 
         # @api private
         def process_operation(op)
-          schemas = op.rules.select { |rule| rule.is_a?(Processor) }
-
-          hash_schema = hash_type.schema(
-            schemas.map(&:schema_dsl).map(&:types).reduce(:merge)
-          )
-
-          type(hash_schema)
+          type(hash_type.schema(merge_operation_types(op)))
         end
 
         # @api private
@@ -44,6 +38,23 @@ module Dry
           schema_dsl.resolve_type(:hash)
         end
 
+        # @api private
+        def merge_operation_types(op)
+          op.rules.reduce({}) do |acc, rule|
+            types =
+              case rule
+              when Dry::Logic::Operations::Abstract
+                merge_operation_types(rule)
+              when Processor
+                rule.types
+              else
+                EMPTY_HASH.dup
+              end
+
+            schema_dsl.merge_types(op.class, acc, types)
+          end
+        end
+
         # @api private
         # rubocop: disable Metrics/AbcSize
         def define(*args, &block)
@@ -51,11 +62,11 @@ module Dry
           schema = definition.call
           type_schema =
             if array_type?(parent_type)
-              build_array_type(parent_type, definition.type_schema)
+              build_array_type(parent_type, definition.strict_type_schema)
             elsif redefined_schema?(args)
               parent_type.schema(definition.types)
             else
-              definition.type_schema
+              definition.strict_type_schema
             end
           final_type = optional? ? type_schema.optional : type_schema
 

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

@@ -30,9 +30,9 @@ module Dry
 
             updated_type =
               if array_type?(current_type)
-                build_array_type(current_type, schema.type_schema)
+                build_array_type(current_type, schema.strict_type_schema)
               else
-                schema.type_schema
+                schema.strict_type_schema
               end
 
             import_steps(schema)

data/lib/dry/schema/message/or/multi_path.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/equalizer"
-
 require "dry/schema/message/or/abstract"
 require "dry/schema/path"
 
@@ -14,23 +12,89 @@ module Dry
         # @api public
         class MultiPath < Abstract
           # @api private
-          attr_reader :root
+          class MessageArray
+            # @api private
+            def initialize(messages)
+              @messages = messages.flatten
+            end
+
+            # @api private
+            def _paths
+              @messages.map(&:_path)
+            end
+
+            # @api private
+            def to_or(root)
+              self.class.new(@messages.map { _1.to_or(root) })
+            end
+
+            # @api private
+            def to_h
+              MessageSet.new(@messages).to_h
+            end
+          end
+
+          MESSAGE_ARRAY_HANDLER = -> { MessageArray.new(_1) }
 
           # @api private
-          def initialize(...)
-            super
-            flat_left = left.flatten
-            flat_right = right.flatten
-            @root = [*flat_left, *flat_right].map(&:_path).reduce(:&)
-            @left = flat_left.map { _1.to_or(root) }
-            @right = flat_right.map { _1.to_or(root) }
+          def self.handler(message)
+            case message
+            when self
+              IDENTITY
+            when Array
+              MESSAGE_ARRAY_HANDLER
+            end
           end
 
           # @api public
           def to_h
-            @to_h ||= Path[[*root, :or]].to_h(
-              [MessageSet.new(left).to_h, MessageSet.new(right).to_h]
-            )
+            @to_h ||= Path[[*root, :or]].to_h(messages.map(&:to_h))
+          end
+
+          # @api private
+          def messages
+            @messages ||= _messages.flat_map { _1.to_or(root) }
+          end
+
+          # @api private
+          def root
+            @root ||= _paths.reduce(:&)
+          end
+
+          # @api private
+          def path
+            root
+          end
+
+          # @api private
+          def _path
+            @_path ||= Path[root]
+          end
+
+          # @api private
+          def _paths
+            @paths ||= _messages.flat_map(&:_paths)
+          end
+
+          # @api private
+          def to_or(root)
+            self.root == root ? messages : [self]
+          end
+
+          private
+
+          # @api private
+          def _messages
+            @_messages ||= [left, right].map do |message|
+              handler = self.class.handler(message)
+
+              unless handler
+                raise ArgumentError,
+                      "#{message.inspect} is of unknown type #{message.class.inspect}"
+              end
+
+              handler.(message)
+            end
           end
         end
       end

data/lib/dry/schema/message/or/single_path.rb

@@ -21,10 +21,11 @@ module Dry
 
           # @api private
           def initialize(*args, messages)
-            super(*args)
+            super(*args.map { [_1].flatten })
             @messages = messages
-            @path = left.path
-            @_path = left._path
+            message = left.first
+            @path = message.path
+            @_path = message._path
           end
 
           # Dump a message into a string
@@ -38,7 +39,7 @@ module Dry
           #
           # @api public
           def dump
-            @dump ||= "#{left.dump} #{messages[:or]} #{right.dump}"
+            @dump ||= [*left, *right].map(&:dump).join(" #{messages[:or]} ")
           end
           alias_method :to_s, :dump
 
@@ -55,7 +56,16 @@ module Dry
 
           # @api private
           def to_a
-            @to_a ||= [left, right]
+            @to_a ||= [*left, *right]
+          end
+
+          # @api private
+          def to_or(root)
+            to_ored = [left, right].map do |msgs|
+              msgs.map { _1.to_or(root) }
+            end
+
+            self.class.new(*to_ored, messages)
           end
         end
       end

data/lib/dry/schema/message/or.rb

@@ -17,8 +17,8 @@ module Dry
 
           if paths.uniq.size == 1
             SinglePath.new(left, right, messages)
-          elsif right.is_a?(Array)
-            if left.is_a?(Array) && paths.uniq.size > 1
+          elsif MultiPath.handler(right)
+            if MultiPath.handler(left) && paths.uniq.size > 1
               MultiPath.new(left, right)
             else
               right

data/lib/dry/schema/message_set.rb

@@ -105,7 +105,7 @@ module Dry
 
       # @api private
       def messages_map(messages = self.messages)
-        combine_message_hashes(messages.map(&:to_h))
+        combine_message_hashes(messages.map(&:to_h)).freeze
       end
 
       # @api private

data/lib/dry/schema/processor.rb

@@ -138,13 +138,22 @@ module Dry
 
       # Return the type schema
       #
-      # @return [Dry::Types::Safe]
+      # @return [Dry::Types::Lax]
       #
       # @api private
       def type_schema
         steps.type_schema
       end
 
+      # Return type schema used when composing subschemas
+      #
+      # @return [Dry::Types::Schema]
+      #
+      # @api private
+      def strict_type_schema
+        schema_dsl.strict_type_schema
+      end
+
       # Return the rule applier
       #
       # @api private
@@ -188,6 +197,13 @@ module Dry
         rule_applier.rules
       end
 
+      # Return the types from the schema DSL
+      #
+      # @api private
+      def types
+        schema_dsl.types
+      end
+
       # Check if there are filter rules
       #
       # @api private

data/lib/dry/schema/types_merger.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # Combines multiple logical operations into a single type, taking into
+    # account the type of logical operation (or, and, implication) and the
+    # underlying types (schemas, nominals, etc.)
+    #
+    # @api private
+    class TypesMerger
+      attr_reader :type_registry
+
+      # @api private
+      class ValueMerger
+        attr_reader :types_merger
+        attr_reader :op_class
+        attr_reader :old
+        attr_reader :new
+
+        # @api private
+        def initialize(types_merger, op_class, old, new)
+          @types_merger = types_merger
+          @op_class = op_class
+          @old = old
+          @new = new
+        end
+
+        # @api private
+        def call
+          if op_class <= Dry::Logic::Operations::Or
+            merge_or
+          elsif op_class <= Dry::Logic::Operations::And
+            merge_and
+          elsif op_class <= Dry::Logic::Operations::Implication
+            merge_implication
+          else
+            raise ArgumentError, <<~MESSAGE
+              Can't merge operations, op_class=#{op_class}
+            MESSAGE
+          end
+        end
+
+        private
+
+        # @api private
+        def merge_or
+          old | new
+        end
+
+        # @api private
+        def merge_ordered
+          return old if old == new
+
+          unwrapped_old, old_rule = unwrap_type(old)
+          unwrapped_new, new_rule = unwrap_type(new)
+
+          type = merge_unwrapped_types(unwrapped_old, unwrapped_new)
+
+          rule = [old_rule, new_rule].compact.reduce { op_class.new(_1, _2) }
+
+          type = Dry::Types::Constrained.new(type, rule: rule) if rule
+
+          type
+        end
+
+        alias_method :merge_and, :merge_ordered
+        alias_method :merge_implication, :merge_ordered
+
+        # @api private
+        def merge_unwrapped_types(unwrapped_old, unwrapped_new)
+          case [unwrapped_old, unwrapped_new]
+          in Dry::Types::Schema, Dry::Types::Schema
+            merge_schemas(unwrapped_old, unwrapped_new)
+          in [Dry::Types::AnyClass, _] | [Dry::Types::Hash, Dry::Types::Schema]
+            unwrapped_new
+          in [Dry::Types::Schema, Dry::Types::Hash] | [_, Dry::Types::AnyClass]
+            unwrapped_old
+          else
+            merge_equivalent_types(unwrapped_old, unwrapped_new)
+          end
+        end
+
+        # @api private
+        def merge_schemas(unwrapped_old, unwrapped_new)
+          types_merger.type_registry["hash"].schema(
+            types_merger.call(
+              op_class,
+              unwrapped_old.name_key_map,
+              unwrapped_new.name_key_map
+            )
+          )
+        end
+
+        # @api private
+        def merge_equivalent_types(unwrapped_old, unwrapped_new)
+          if unwrapped_old.primitive <= unwrapped_new.primitive
+            unwrapped_new
+          elsif unwrapped_new.primitive <= unwrapped_old.primitive
+            unwrapped_old
+          else
+            raise ArgumentError, <<~MESSAGE
+              Can't merge types, unwrapped_old=#{unwrapped_old.inspect}, unwrapped_new=#{unwrapped_new.inspect}
+            MESSAGE
+          end
+        end
+
+        # @api private
+        def unwrap_type(type)
+          rules = []
+
+          loop do
+            rules << type.rule if type.respond_to?(:rule)
+
+            if type.optional?
+              type = type.left.primitive?(nil) ? type.right : type.left
+            elsif type.is_a?(Dry::Types::Decorator)
+              type = type.type
+            else
+              break
+            end
+          end
+
+          [type, rules.reduce(:&)]
+        end
+      end
+
+      def initialize(type_registry = TypeRegistry.new)
+        @type_registry = type_registry
+      end
+
+      # @api private
+      def call(op_class, lhs, rhs)
+        lhs.merge(rhs) do |_k, old, new|
+          ValueMerger.new(self, op_class, old, new).call
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Schema
-    VERSION = "1.9.2"
+    VERSION = "1.10.2"
   end
 end

data/lib/dry/schema.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "dry/core/extensions"
+require "dry/configurable"
+require "dry/logic"
 
 require "dry/schema/config"
 require "dry/schema/constants"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-schema
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.10.2
 platform: ruby
 authors:
 - Piotr Solnica
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-28 00:00:00.000000000 Z
+date: 2022-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -230,6 +230,7 @@ files:
 - lib/dry/schema/type_container.rb
 - lib/dry/schema/type_registry.rb
 - lib/dry/schema/types.rb
+- lib/dry/schema/types_merger.rb
 - lib/dry/schema/value_coercer.rb
 - lib/dry/schema/version.rb
 homepage: https://dry-rb.org/gems/dry-schema
@@ -240,7 +241,7 @@ metadata:
   changelog_uri: https://github.com/dry-rb/dry-schema/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/dry-rb/dry-schema
   bug_tracker_uri: https://github.com/dry-rb/dry-schema/issues
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -255,9 +256,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: Coercion and validation for data structures
 test_files: []
-...