dry-schema 1.14.1 → 1.15.0

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2023 dry-rb team
+Copyright (c) 2015-2026 Hanakai 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,22 +1,17 @@
-<!--- this file is synced from dry-rb/template-gem project -->
-[gem]: https://rubygems.org/gems/dry-schema
+<!--- This file is synced from hanakai-rb/repo-sync -->
+
+[rubygem]: https://rubygems.org/gems/dry-schema
 [actions]: https://github.com/dry-rb/dry-schema/actions
 
-# dry-schema [![Gem Version](https://badge.fury.io/rb/dry-schema.svg)][gem] [![CI Status](https://github.com/dry-rb/dry-schema/workflows/CI/badge.svg)][actions]
+# dry-schema [![Gem Version](https://badge.fury.io/rb/dry-schema.svg)][rubygem] [![CI Status](https://github.com/dry-rb/dry-schema/workflows/CI/badge.svg)][actions]
 
 ## Links
 
-* [User documentation](https://dry-rb.org/gems/dry-schema)
-* [API documentation](http://rubydoc.info/gems/dry-schema)
-* [Forum](https://discourse.dry-rb.org)
-
-## Supported Ruby versions
-
-This library officially supports the following Ruby versions:
-
-* MRI `>= 3.1`
-* jruby `>= 9.4` (not tested on CI)
+- [User documentation](https://dry-rb.org/gems/dry-schema)
+- [API documentation](http://rubydoc.info/gems/dry-schema)
+- [Forum](https://discourse.dry-rb.org)
 
 ## License
 
 See `LICENSE` file.
+

data/config/errors.yml

@@ -117,5 +117,11 @@ en:
 
       uuid_v5?: "is not a valid UUID"
 
+      uuid_v6?: "is not a valid UUID"
+
+      uuid_v7?: "is not a valid UUID"
+
+      uuid_v8?: "is not a valid UUID"
+
       not:
         empty?: "cannot be empty"

data/dry-schema.gemspec

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# this file is synced from dry-rb/template-gem project
+# This file is synced from hanakai-rb/repo-sync. To update it, edit repo-sync.yml.
 
 lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -8,8 +8,8 @@ require "dry/schema/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "dry-schema"
-  spec.authors       = ["Piotr Solnica"]
-  spec.email         = ["piotr.solnica@gmail.com"]
+  spec.authors       = ["Hanakai team"]
+  spec.email         = ["info@hanakai.org"]
   spec.license       = "MIT"
   spec.version       = Dry::Schema::VERSION.dup
 
@@ -18,29 +18,33 @@ Gem::Specification.new do |spec|
     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.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/main/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.metadata["rubygems_mfa_required"] = "true"
-
-  spec.required_ruby_version = ">= 3.1"
-
-  # to update dependencies edit project.yml
-  spec.add_dependency "concurrent-ruby", "~> 1.0"
-  spec.add_dependency "dry-configurable", "~> 1.0", ">= 1.0.1"
-  spec.add_dependency "dry-core", "~> 1.1"
-  spec.add_dependency "dry-initializer", "~> 3.2"
-  spec.add_dependency "dry-logic", "~> 1.5"
-  spec.add_dependency "dry-types", "~> 1.8"
-  spec.add_dependency "zeitwerk", "~> 2.6"
+  spec.extra_rdoc_files = ["README.md", "CHANGELOG.md", "LICENSE"]
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["changelog_uri"]     = "https://github.com/dry-rb/dry-schema/blob/main/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.metadata["funding_uri"]       = "https://github.com/sponsors/hanami"
+
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_runtime_dependency "zeitwerk", "~> 2.6"
+  spec.add_runtime_dependency "dry-core", "~> 1.1"
+  spec.add_runtime_dependency "dry-configurable", "~> 1.0", ">= 1.0.1"
+  spec.add_runtime_dependency "dry-initializer", "~> 3.2"
+  spec.add_runtime_dependency "dry-logic", "~> 1.6"
+  spec.add_runtime_dependency "dry-types", "~> 1.8"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "yard"
 end
+

data/lib/dry/schema/config.rb

@@ -46,7 +46,7 @@ module Dry
         setting :backend, default: :yaml
         setting :namespace
         setting :load_paths, default: ::Set[DEFAULT_MESSAGES_PATH], constructor: :dup.to_proc
-        setting :top_namespace, default: DEFAULT_MESSAGES_ROOT
+        setting :top_namespace, default: DEFAULT_MESSAGES_ROOT, constructor: :to_s.to_proc
         setting :default_locale
       end
 

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

@@ -28,6 +28,14 @@ module Dry
           time?: {type: "string", format: "time"},
           min_size?: {minLength: TO_INTEGER},
           max_size?: {maxLength: TO_INTEGER},
+          size?: {maxLength: TO_INTEGER, minLength: TO_INTEGER},
+          format?: {
+            pattern: proc do |x|
+              x.to_s.delete_prefix("(?-mix:").delete_suffix(")")
+            end
+          },
+          true?: {},
+          false?: {},
           included_in?: {enum: ->(v, _) { v.to_a }},
           filled?: EMPTY_HASH,
           uri?: {format: "uri"},
@@ -46,6 +54,15 @@ module Dry
           uuid_v5?: {
             pattern: "^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$"
           },
+          uuid_v6?: {
+            pattern: "^[0-9A-F]{8}-[0-9A-F]{4}-6[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$"
+          },
+          uuid_v7?: {
+            pattern: "^[0-9A-F]{8}-[0-9A-F]{4}-7[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$"
+          },
+          uuid_v8?: {
+            pattern: "^[0-9A-F]{8}-[0-9A-F]{4}-8[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$"
+          },
           gt?: {exclusiveMinimum: IDENTITY},
           gteq?: {minimum: IDENTITY},
           lt?: {exclusiveMaximum: IDENTITY},
@@ -163,18 +180,64 @@ module Dry
           name, rest = node
 
           if name.equal?(:key?)
-            prop_name = rest[0][1]
-            keys[prop_name] = {}
+            handle_key_predicate(rest)
           else
-            target = keys[opts[:key]]
-            type_opts = fetch_type_opts_for_predicate(name, rest, target)
-
-            if target[:type]&.include?("array")
-              target[:items] ||= {}
-              merge_opts!(target[:items], type_opts)
-            else
-              merge_opts!(target, type_opts)
-            end
+            handle_value_predicate(name, rest, opts)
+          end
+        end
+
+        # @api private
+        def handle_key_predicate(rest)
+          prop_name = rest[0][1]
+          keys[prop_name] = {}
+        end
+
+        # @api private
+        def handle_value_predicate(name, rest, opts)
+          target = keys[opts[:key]]
+          type_opts = fetch_type_opts_for_predicate(name, rest, target)
+
+          if array_with_size_predicate?(target, name, opts)
+            apply_array_size_constraint(target, name, rest)
+          elsif target[:type]&.include?("array")
+            apply_array_item_constraint(target, type_opts)
+          else
+            merge_opts!(target, type_opts)
+          end
+        end
+
+        # @api private
+        def array_with_size_predicate?(target, name, opts)
+          target[:type]&.include?("array") && array_size_predicate?(name) && !opts[:member]
+        end
+
+        # @api private
+        def apply_array_size_constraint(target, name, rest)
+          array_type_opts = convert_array_size_predicate(name, rest)
+          merge_opts!(target, array_type_opts)
+        end
+
+        # @api private
+        def apply_array_item_constraint(target, type_opts)
+          target[:items] ||= {}
+          merge_opts!(target[:items], type_opts)
+        end
+
+        # @api private
+        def array_size_predicate?(name)
+          name == :min_size? || name == :max_size?
+        end
+
+        # @api private
+        def convert_array_size_predicate(name, rest)
+          value = rest[0][1].to_i
+          case name
+          when :min_size?
+            {minItems: value}
+          when :max_size?
+            {maxItems: value}
+          else
+            {}
           end
         end
 

data/lib/dry/schema/extensions/struct.rb

@@ -27,7 +27,8 @@ module Dry
                                    "a struct class (#{name.inspect} => #{args[0]})"
             end
 
-            schema = struct_compiler.(args[0])
+            struct_class = extract_struct_class(args[0])
+            schema = struct_compiler.(struct_class)
 
             super(schema, *args.drop(1))
             type(schema_dsl.types[name].constructor(schema))
@@ -39,7 +40,18 @@ module Dry
         private
 
         def struct?(type)
-          type.is_a?(::Class) && type <= ::Dry::Struct
+          (type.is_a?(::Class) && type <= ::Dry::Struct) ||
+            (type.is_a?(::Dry::Types::Constructor) && type.primitive <= ::Dry::Struct)
+        end
+
+        def extract_struct_class(type)
+          if type.is_a?(::Class) && type <= ::Dry::Struct
+            type
+          elsif type.is_a?(::Dry::Types::Constructor) && type.primitive <= ::Dry::Struct
+            type.primitive
+          else
+            type
+          end
         end
       })
     end

data/lib/dry/schema/key_validator.rb

@@ -9,6 +9,7 @@ module Dry
     class KeyValidator
       extend ::Dry::Initializer
 
+      MULTI_INDEX_REGEX = /(\[\d+\])+/
       INDEX_REGEX = /\[\d+\]/
       DIGIT_REGEX = /\A\d+\z/
       BRACKETS = "[]"
@@ -38,10 +39,10 @@ module Dry
 
       # @api private
       def validate_path(key_paths, path)
-        if path[INDEX_REGEX]
-          key = path.gsub(INDEX_REGEX, BRACKETS)
+        if path[MULTI_INDEX_REGEX]
+          key = path.gsub(MULTI_INDEX_REGEX, BRACKETS)
           if none_key_paths_match?(key_paths, key)
-            arr = path.gsub(INDEX_REGEX) { ".#{_1[1]}" }
+            arr = path.gsub(INDEX_REGEX) { ".#{_1[1...-1]}" }
             arr.split(DOT).map { DIGIT_REGEX.match?(_1) ? Integer(_1, 10) : _1.to_sym }
           end
         elsif none_key_paths_match?(key_paths, path)
@@ -83,9 +84,7 @@ module Dry
             if hashes_or_arrays.empty?
               [key.to_s]
             else
-              hashes_or_arrays.flat_map.with_index { |el, idx|
-                key_paths(el).map { ["#{key}[#{idx}]", *_1].join(DOT) }
-              }
+              traverse_array(value).map { |sub_path| [key, sub_path].join("") }
             end
           else
             key.to_s
@@ -99,6 +98,20 @@ module Dry
           (x.is_a?(::Array) || x.is_a?(::Hash)) && !x.empty?
         }
       end
+
+      # @api private
+      def traverse_array(arr)
+        arr.each_with_index.flat_map do |el, idx|
+          case el
+          when ::Hash
+            key_paths(el).map { ["[#{idx}]", *_1].join(DOT) }
+          when ::Array
+            traverse_array(el).map { ["[#{idx}]", *_1].join("") }
+          else
+            []
+          end
+        end
+      end
     end
   end
 end

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

@@ -234,6 +234,10 @@ module Dry
               type_rule = [type_spec.left, type_spec.right].map { |ts|
                 new(klass: Core, chain: false).value(ts)
               }.reduce(:|)
+            elsif type_spec.is_a?(Dry::Types::Intersection) && set_type
+              type_rule = [type_spec.left, type_spec.right].map { |ts|
+                new(klass: Core, chain: false).value(ts)
+              }.reduce(:&)
             else
               type_predicates = predicate_inferrer[resolved_type]
 

data/lib/dry/schema/message.rb

@@ -81,7 +81,7 @@ module Dry
       # @api private
       def to_or(root)
         clone = dup
-        clone.instance_variable_set("@path", path - root.to_a)
+        clone.instance_variable_set("@path", remove_prefix(path, prefix: root.to_a))
         clone.instance_variable_set("@_path", nil)
         clone
       end
@@ -104,6 +104,13 @@ module Dry
       def _path
         @_path ||= Path[path]
       end
+
+      private
+
+      def remove_prefix(array, prefix:)
+        has_prefix = array[0, prefix.length] == prefix
+        has_prefix ? array[prefix.length..] : array.dup
+      end
     end
   end
 end

data/lib/dry/schema/message_compiler.rb

@@ -224,9 +224,9 @@ module Dry
       # @api private
       def append_mapped_size_tokens(tokens)
         # this is a temporary fix for the inconsistency in the "size" errors arguments
-        mapped_hash = tokens.each_with_object({}) { |(k, v), h|
-          h[k.to_s.gsub("size", "num").to_sym] = v
-        }
+        mapped_hash = tokens.transform_keys do |k|
+          k.to_s.gsub("size", "num").to_sym
+        end
         tokens.merge(mapped_hash)
       end
     end

data/lib/dry/schema/messages/abstract.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require "concurrent/map"
 
 require "dry/schema/constants"

data/lib/dry/schema/messages/i18n.rb

@@ -32,7 +32,8 @@ module Dry
         def get(key, options = EMPTY_HASH)
           return unless key
 
-          result = t.(key, locale: options.fetch(:locale, default_locale))
+          options[:locale] ||= default_locale
+          result = t.(key, **options)
 
           if result.is_a?(Hash)
             text = result[:text]
@@ -112,7 +113,10 @@ module Dry
 
           resolved_key = key?(text_key, opts) ? text_key : key
 
-          t.(resolved_key, **opts)
+          result = t.(resolved_key, **opts)
+          return result unless result.is_a?(Hash)
+
+          result[:text]
         end
 
         private

data/lib/dry/schema/predicate_inferrer.rb

@@ -4,7 +4,16 @@ module Dry
   module Schema
     # @api private
     class PredicateInferrer < ::Dry::Types::PredicateInferrer
-      Compiler = ::Class.new(superclass::Compiler)
+      Compiler = ::Class.new(superclass::Compiler) do
+        # @api private
+        def visit_intersection(node)
+          left_node, right_node, = node
+          left = visit(left_node)
+          right = visit(right_node)
+
+          [left, right].flatten.compact
+        end
+      end
 
       def initialize(registry = PredicateRegistry.new)
         super

data/lib/dry/schema/primitive_inferrer.rb

@@ -4,7 +4,13 @@ module Dry
   module Schema
     # @api private
     class PrimitiveInferrer < ::Dry::Types::PrimitiveInferrer
-      Compiler = ::Class.new(superclass::Compiler)
+      Compiler = ::Class.new(superclass::Compiler) do
+        # @api private
+        def visit_intersection(node)
+          left, right = node
+          [visit(left), visit(right)].flatten(1)
+        end
+      end
 
       def initialize
         super

data/lib/dry/schema/trace.rb

@@ -7,6 +7,7 @@ module Dry
     # @api private
     class Trace < ::BasicObject
       INVALID_PREDICATES = %i[key?].freeze
+      RESPOND_TO_MISSING_METHOD = ::Kernel.instance_method(:respond_to_missing?)
 
       include ::Dry::Equalizer(:compiler, :captures)
 
@@ -86,12 +87,13 @@ module Dry
       end
 
       def respond_to_missing?(meth, include_private = false)
-        super || (meth.to_s.end_with?(QUESTION_MARK) && compuiler.support?(meth))
+        RESPOND_TO_MISSING_METHOD.bind_call(self, meth, include_private) ||
+          (meth.to_s.end_with?(QUESTION_MARK) && compiler.support?(meth))
       end
 
       # @api private
       def method_missing(meth, *args, &block)
-        if meth.to_s.end_with?(QUESTION_MARK)
+        if !meth.equal?(:respond_to_missing?) && meth.to_s.end_with?(QUESTION_MARK)
           if ::Dry::Schema::Trace::INVALID_PREDICATES.include?(meth)
             ::Kernel.raise InvalidSchemaError, "#{meth} predicate cannot be used in this context"
           end

data/lib/dry/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Schema
-    VERSION = "1.14.1"
+    VERSION = "1.15.0"
   end
 end