schemacop 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ef422cfe57686302457be2282f2b8e5f45ccdc79d6cd62597e8308bbb94026e
-  data.tar.gz: d45307834a863e1fdfdf616acbb9727fd78db428ce88436c27a67db88a3e802f
+  metadata.gz: f790c910d2c32accea93c9f4e67b85c80ababfbaca2b64930d7e380a65125d9e
+  data.tar.gz: ae3f22c58697112408efde125190a0cd8518199ceb8b47b65094e289d9e8769d
 SHA512:
-  metadata.gz: 1253508e8f7270b6fa5f8f54563e79fa034a97fa8f89334f416d0e4549a5b374a2cdc0b3b4777e15202a7759a275d389a8390d67efd7acbb9114de38e21aceb1
-  data.tar.gz: 5aa472bf5a7d1aa37f946cf298b76349ad4faee611491c0ecf1bd377baa1127cfaae668f4a71ad00381a0afa88b5c23d073a3b84018ee5387808ad645766b37a
+  metadata.gz: b3f20de721d5e94f4bbb1504292c8ecd7136ae8468e8fde9d0885e9503aee4c6f950e7bd888ea50067d0dbf40c3dd0e36ab12d2ee674143a28405bd3c70bfe2f
+  data.tar.gz: efd82ce7677ee0c3d5031af98997840cd6cf38a3aa2337e68ead04e383add88e32d29f15d08ad0739e47691c48299f329c547677abd6aca1118a29fe6308a4e4

data/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Change log
 
+## 3.1.1 (2026-09-08)
+
+* Fix crashes when validating strings whose encoding does not fit their
+  contents or the schema:
+
+  * A string with an invalid byte sequence is reported as such and no longer
+    handed to `allow_blank`, `pattern` and `format`, which decode it and
+    therefore raised an `ArgumentError`. The checks that do not decode the
+    string (`min_length`, `max_length`, `encoding` and `enum`) are still
+    reported.
+
+  * A string that cannot be compared with the `pattern` or with the pattern of
+    the given `format` because their encodings are incompatible (e.g. a UTF-16
+    string) is reported as not matching it, rather than raising an
+    `Encoding::CompatibilityError` or a `RegexpError`. The same holds for
+    `allow_blank`, `dep` dependencies and `treat_blank_as_nil`, which treat
+    such a string as blank only if it is empty.
+
+  * Hash keys and values with an invalid byte sequence no longer raise an
+    `ArgumentError` or an `EncodingError` when used together with
+    `property_names`, pattern properties, `ignore_obsolete_properties` or `dep`
+    dependencies. Such a key matches none of the patterns.
+
+  * A key with an invalid byte sequence in the path of a validation error no
+    longer makes `Result#messages`, `Result#exception_message` and `validate!`
+    raise an `ArgumentError`. The invalid bytes are replaced in the path of the
+    message.
+
+  * The `encoding` error of a string is now reported before its `pattern` and
+    `format` errors, rather than after them.
+
+  Internal reference: `#153682`.
+
+* Anchor the patterns of the built-in string formats with `\A` and `\z` instead
+  of `^` and `$`, which match at the start and the end of every line in Ruby. A
+  multi-line string passed the validation as soon as one of its lines matched
+  and was then handed to the cast handler: `"32\ntest"` passed the `integer`
+  format and raised an `ArgumentError`, `"true\n"` passed the `boolean` format
+  and was cast to `false`. A value with a trailing newline is rejected as well
+  now, where it used to pass and be cast. Affects the formats `date`,
+  `date-time`, `time`, `mailbox`, `boolean`, `integer`, `number` and
+  `integer-list`.
+
+  Internal reference: `#153681`.
+
+* Require `tempfile`, which the `bin` node needs. Requiring the gem outside of
+  Rails failed with a `NameError` for `Tempfile`.
+
+* Fix `ignore_obsolete_properties` ignoring an allow list given as strings
+  (e.g. `ignore_obsolete_properties: %w[foo]`), which reported the listed
+  properties as obsolete. Strings and symbols are now treated alike.
+
+* Fix a `NoMethodError` when casting a hash that declares pattern properties
+  and contains a key matching none of them.
+
+* Fix casting of hash properties that are specified in the schema: in a hash
+  that also declares pattern properties or additional properties, they were
+  casted a second time as such, which could cast them with the wrong node and
+  added the original key to the result next to the one given via `as`.
+
 ## 3.1.0 (2026-05-09)
 
 * Add option `encoding` to `str` node for Schemacop V3 schemas to validate that

data/README_V3.md

@@ -213,8 +213,17 @@ transformed into various types.
 * `pattern`
   Defines a (ruby) regex pattern the value will be matched against. Must be either
   a string which should not be enclosed in `/` characters, or a Ruby Regexp.
-  The pattern should generally start with `^` and end with `$` so as to evaluate
-  the entire string.
+  The pattern should generally be anchored so as to evaluate the entire string.
+  In Ruby, `^` and `$` match at the start and the end of every *line*, so
+  `/^[0-9]+$/` accepts `"32\nfoo"`; `\A` and `\z` match only at the start and
+  the end of the string.
+
+  Patterns are exported to the JSON schema verbatim, and JSON Schema uses the
+  ECMA-262 dialect, which knows no `\A` and `\z` (it reads them as the literal
+  characters `A` and `z`) and where `^` and `$` already match the whole string
+  only. A pattern can therefore be correct on one side or the other, but not on
+  both: use `\A` and `\z` for schemas that are validated in Ruby, and `^` and
+  `$` for schemas that are exported and validated elsewhere.
 * `format`
   The `format` option allows for basic semantic validation on certain kinds of
   string values that are commonly used. See section *formats* for more
@@ -232,7 +241,15 @@ transformed into various types.
 
 Note that regardless of the `encoding` option, all strings are validated for
 valid encoding using `valid_encoding?`. Strings with invalid byte sequences for
-their declared encoding will always produce a validation error.
+their declared encoding will always produce a validation error. The `pattern`
+and `format` of such a string are not checked, as matching a pattern requires
+decoding it; the checks that do not decode the string (`min_length`,
+`max_length`, `encoding` and `enum`) are still reported.
+
+A string whose encoding is valid but cannot be compared with the `pattern` or
+with the pattern of the given `format` (e.g. a UTF-16 string) is reported as not
+matching it, rather than raising an error. Note that `min_length` and
+`max_length` count bytes for such an encoding, as it has no characters.
 
 #### Formats
 
@@ -295,12 +312,16 @@ You can also implement your custom formats or override the behavior of the
 standard formats. For Rails applications, this can be done in
 `config/schemacop.rb`:
 
+Anchor the pattern with `\A` and `\z`. In Ruby, `^` and `$` match at the start
+and the end of every line, so a multi-line value would pass the validation and
+reach your handler.
+
 ```ruby
 # config/schemacop.rb
 Schemacop.register_string_formatter(
-  :character_array,                        # Formatter name
-  pattern: /^[a-zA-Z](,[a-zA-Z])*/,        # Regex pattern for validation
-  handler: ->(value) { value.split(',') }  # Casting callback
+  :character_array,                          # Formatter name
+  pattern: /\A[a-zA-Z](,[a-zA-Z])*\z/,       # Regex pattern for validation
+  handler: ->(value) { value.split(',') }    # Casting callback
 )
 
 # In your schema
@@ -936,6 +957,9 @@ It consists of key-value-pairs that can be validated using arbitrary nodes.
   This option allows to specify a regexp pattern (as string) which validates the
   keys of any properties that are not specified in the hash. This option only
   makes sense if `additional_properties` is enabled. See below for more information.
+  The pattern is anchored the same way as the `pattern` option of the string
+  node, i.e. a pattern using `^` and `$` accepts a key that matches on any of
+  its lines.
 
 * `min_properties`
   Specifies the (inclusive) minimum number of properties a hash must contain.

data/VERSION

@@ -1 +1 @@
-3.1.0
+3.1.1

data/lib/schemacop/v3/hash_node.rb

@@ -168,21 +168,26 @@ module Schemacop
         property_names = options[:property_names]
         property_names = Regexp.compile(property_names) if property_names
 
+        # `name.to_sym` raises an EncodingError on a key with an invalid byte
+        # sequence, so the allow list is compared as strings.
+        if options[:ignore_obsolete_properties].is_a?(Enumerable)
+          obsolete_allow_list = options[:ignore_obsolete_properties].to_set(&:to_s)
+        end
+
         additional_properties.each do |name, additional_property|
-          if property_names && !property_names.match?(name)
+          if property_names && !V3.match?(property_names, name.to_s)
             result.error "Property name #{name.inspect} does not match #{options[:property_names].inspect}."
           end
 
           if options[:additional_properties].is_a?(TrueClass)
             next
           elsif options[:additional_properties].is_a?(FalseClass) || options[:additional_properties].blank?
-            match = property_patterns.keys.find { |p| p.match?(name.to_s) }
+            match = property_patterns.keys.find { |p| V3.match?(p, name.to_s) }
             if match
               result.in_path(name) do
                 property_patterns[match]._validate(additional_property, result: result)
               end
-            elsif (options[:ignore_obsolete_properties].is_a?(Enumerable) &&
-                   options[:ignore_obsolete_properties].exclude?(name.to_sym)) ||
+            elsif obsolete_allow_list&.exclude?(name.to_s) ||
                   !options[:ignore_obsolete_properties]
               result.error "Obsolete property #{name.to_s.inspect}."
             end
@@ -196,7 +201,7 @@ module Schemacop
         # Validate dependencies #
         options[:dependencies]&.each do |source, targets|
           targets.each do |target|
-            if data_hash[source].present? && data_hash[target].blank?
+            if !V3.blank?(data_hash[source]) && V3.blank?(data_hash[target])
               result.error "Missing property #{target.to_s.inspect} because #{source.to_s.inspect} is given."
             end
           end
@@ -268,23 +273,24 @@ module Schemacop
         end
 
         # Handle regex properties
+        # Property names are strings, see Node#init.
         specified_properties = @properties.keys.to_set + inline_ref_property_names
-        additional_properties = data_hash.reject { |k, _v| specified_properties.include?(k.to_s.to_sym) }
+        additional_properties = data_hash.reject { |k, _v| specified_properties.include?(k.to_s) }
 
         if additional_properties.any? && property_patterns.any?
           additional_properties.each do |name, additional_property|
-            match_key = property_patterns.keys.find { |p| p.match?(name.to_s) }
-            match = property_patterns[match_key]
-            result[name] = match.cast(additional_property)
+            match_key = property_patterns.keys.find { |p| V3.match?(p, name.to_s) }
+            next unless match_key
+
+            result[name] = property_patterns[match_key].cast(additional_property)
           end
         end
 
         # Handle additional properties
         if options[:additional_properties].is_a?(TrueClass)
-          result = data_hash.merge(result)
+          result = data_hash.reject { |k, _v| specified_properties.include?(k.to_s) }.merge(result)
         elsif options[:additional_properties].is_a?(Node)
-          add_prop_specified = @properties.keys.to_set + inline_ref_property_names
-          additional_properties = data_hash.reject { |k, _v| add_prop_specified.include?(k.to_s.to_sym) }
+          additional_properties = data_hash.reject { |k, _v| specified_properties.include?(k.to_s) }
           if additional_properties.any?
             additional_properties_result = {}
             additional_properties.each do |key, value|

data/lib/schemacop/v3/one_of_node.rb

@@ -13,7 +13,7 @@ module Schemacop
         item = match(value)
 
         unless item
-          if options[:treat_blank_as_nil] && value.blank? && !value.is_a?(FalseClass)
+          if options[:treat_blank_as_nil] && V3.blank?(value) && !value.is_a?(FalseClass)
             return nil
           else
             return value
@@ -37,7 +37,7 @@ module Schemacop
       public
 
       def _validate(data, result:)
-        if options[:treat_blank_as_nil] && data.blank? && !data.is_a?(FalseClass)
+        if options[:treat_blank_as_nil] && V3.blank?(data) && !data.is_a?(FalseClass)
           data = nil
         end
 

data/lib/schemacop/v3/result.rb

@@ -55,10 +55,23 @@ module Schemacop
 
     def in_path(segment)
       prev_path = @current_path
-      @current_path += [segment]
+      @current_path += [sanitize_segment(segment)]
       yield
     ensure
       @current_path = prev_path
     end
+
+    private
+
+    # A path segment can be a key of the validated data and therefore carry any
+    # encoding. Joining or splitting a message built from a string with an
+    # invalid byte sequence, or from one that is incompatible with the other
+    # messages, raises.
+    def sanitize_segment(segment)
+      return segment unless segment.is_a?(String)
+      return segment if segment.valid_encoding? && Encoding.compatible?(Encoding::UTF_8, segment)
+
+      return segment.scrub.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+    end
   end
 end

data/lib/schemacop/v3/string_node.rb

@@ -27,7 +27,7 @@ module Schemacop
         super_data = super
 
         # Validate blank #
-        if options[:allow_blank].is_a?(FalseClass) && super_data.blank?
+        if options[:allow_blank].is_a?(FalseClass) && V3.blank?(super_data)
           result.error 'String is blank but must not be blank!'
         end
 
@@ -44,17 +44,6 @@ module Schemacop
           result.error "String is #{length} characters long but must be at most #{options[:max_length]}."
         end
 
-        # Validate pattern #
-        if (pattern = options[:pattern])
-          unless options[:pattern].is_a?(Regexp)
-            pattern = Regexp.compile(pattern)
-          end
-
-          unless super_data.match?(pattern)
-            result.error "String does not match pattern #{V3.sanitize_exp(pattern).inspect}."
-          end
-        end
-
         # Validate encoding matches #
         if options[:encoding]
           allowed_encodings = Array(options[:encoding])
@@ -63,16 +52,30 @@ module Schemacop
           end
         end
 
-        # Validate encoding #
+        # Validate byte sequence #
+        # `match?` raises an ArgumentError on an invalid byte sequence, so no
+        # check below may see such a string.
         unless super_data.valid_encoding?
           result.error "String has invalid #{super_data.encoding.name.inspect} encoding."
+          return
+        end
+
+        # Validate pattern #
+        if (pattern = options[:pattern])
+          unless options[:pattern].is_a?(Regexp)
+            pattern = Regexp.compile(pattern)
+          end
+
+          unless V3.match?(pattern, super_data)
+            result.error "String does not match pattern #{V3.sanitize_exp(pattern).inspect}."
+          end
         end
 
         # Validate format #
         if options[:format] && Schemacop.string_formatters.include?(options[:format])
           pattern = Schemacop.string_formatters[options[:format]][:pattern]
 
-          if pattern && !super_data.match?(pattern)
+          if pattern && !V3.match?(pattern, super_data)
             result.error "String does not match format #{options[:format].to_s.inspect}."
           elsif options[:format_options] && Node.resolve_class(options[:format])
             node = create(options[:format], **options[:format_options])

data/lib/schemacop/v3.rb

@@ -4,6 +4,38 @@ module Schemacop
       NodeRegistry.register(*args)
     end
 
+    # `String#blank?` matches a regular expression and therefore raises on a
+    # string it cannot compare: an `ArgumentError` on an invalid byte sequence,
+    # a `RegexpError` on a dummy encoding such as UTF-16. Neither kind of
+    # string is blank unless it is empty.
+    # @private
+    def self.blank?(value)
+      return false if invalid_encoding?(value)
+
+      return value.blank?
+    rescue Encoding::CompatibilityError, RegexpError
+      return value.empty?
+    end
+
+    # `Regexp#match?` raises on a string it cannot compare: an `ArgumentError`
+    # on an invalid byte sequence, an `Encoding::CompatibilityError` on an
+    # encoding incompatible with the pattern's. Neither kind of string matches.
+    # @private
+    def self.match?(pattern, value)
+      return false if invalid_encoding?(value)
+
+      begin
+        return pattern.match?(value)
+      rescue Encoding::CompatibilityError
+        return false
+      end
+    end
+
+    # @private
+    def self.invalid_encoding?(value)
+      return value.is_a?(String) && !value.valid_encoding?
+    end
+
     # @private
     def self.sanitize_exp(exp)
       return exp if exp.is_a?(String)

data/lib/schemacop.rb

@@ -5,6 +5,7 @@ require 'active_support/all'
 require 'set'
 require 'uri'
 require 'resolv'
+require 'tempfile'
 
 # Schemacop module
 module Schemacop
@@ -22,6 +23,8 @@ module Schemacop
   mattr_accessor :v3_default_options
   self.v3_default_options = {}
 
+  # The pattern must be anchored with \A and \z: ^ and $ match at the start and
+  # the end of every line, so a multi-line value would reach the handler.
   def self.register_string_formatter(name, pattern:, handler:)
     name = name.to_s.dasherize.to_sym
 
@@ -33,21 +36,21 @@ module Schemacop
 
   register_string_formatter(
     :date,
-    pattern: /^([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])$/,
+    pattern: /\A([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])\z/,
     handler: ->(value) { Date.parse(value) }
   )
 
   # rubocop: disable Layout/LineLength
   register_string_formatter(
     :'date-time',
-    pattern: /^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$/,
+    pattern: /\A(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?\z/,
     handler: ->(value) { DateTime.parse(value) }
   )
   # rubocop: enable Layout/LineLength
 
   register_string_formatter(
     :time,
-    pattern: /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$/,
+    pattern: /\A(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?\z/,
     handler: ->(value) { Time.parse(value) }
   )
 
@@ -59,12 +62,12 @@ module Schemacop
 
   register_string_formatter(
     :mailbox,
-    pattern: /^("\p{Print}+"\s)?<#{URI::MailTo::EMAIL_REGEXP.source[2...-2]}>$/,
+    pattern: /\A("\p{Print}+"\s)?<#{URI::MailTo::EMAIL_REGEXP.source[2...-2]}>\z/,
     handler: ->(value) { value }
   )
   register_string_formatter(
     :boolean,
-    pattern: /^(true|false|0|1)$/i,
+    pattern: /\A(true|false|0|1)\z/i,
     handler: ->(value) { %w[true 1].include?(value&.downcase) }
   )
 
@@ -82,13 +85,13 @@ module Schemacop
 
   register_string_formatter(
     :integer,
-    pattern: /^-?[0-9]+$/,
+    pattern: /\A-?[0-9]+\z/,
     handler: ->(value) { Integer(value, 10) }
   )
 
   register_string_formatter(
     :number,
-    pattern: /^-?[0-9]+(\.[0-9]+)?$/,
+    pattern: /\A-?[0-9]+(\.[0-9]+)?\z/,
     handler: proc do |value|
       if value.include?('.')
         Float(value)
@@ -100,7 +103,7 @@ module Schemacop
 
   register_string_formatter(
     :'integer-list',
-    pattern: /^(-?[0-9]+)(,-?[0-9]+)*$/,
+    pattern: /\A(-?[0-9]+)(,-?[0-9]+)*\z/,
     handler: ->(value) { value.split(',').map { |i| Integer(i, 10) } }
   )
 

data/schemacop.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: schemacop 3.1.0 ruby lib
+# stub: schemacop 3.1.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "schemacop".freeze
-  s.version = "3.1.0".freeze
+  s.version = "3.1.1".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Sitrox".freeze]
-  s.date = "2026-05-12"
+  s.date = "2026-09-08"
   s.files = [".github/workflows/ruby.yml".freeze, ".gitignore".freeze, ".releaser_config".freeze, ".rubocop.yml".freeze, ".yardopts".freeze, "CHANGELOG.md".freeze, "Gemfile".freeze, "LICENSE".freeze, "README.md".freeze, "README_V2.md".freeze, "README_V3.md".freeze, "RUBY_VERSION".freeze, "Rakefile".freeze, "VERSION".freeze, "lib/schemacop.rb".freeze, "lib/schemacop/base_schema.rb".freeze, "lib/schemacop/exceptions.rb".freeze, "lib/schemacop/railtie.rb".freeze, "lib/schemacop/schema.rb".freeze, "lib/schemacop/schema2.rb".freeze, "lib/schemacop/schema3.rb".freeze, "lib/schemacop/scoped_env.rb".freeze, "lib/schemacop/v2.rb".freeze, "lib/schemacop/v2/caster.rb".freeze, "lib/schemacop/v2/collector.rb".freeze, "lib/schemacop/v2/dupper.rb".freeze, "lib/schemacop/v2/field_node.rb".freeze, "lib/schemacop/v2/node.rb".freeze, "lib/schemacop/v2/node_resolver.rb".freeze, "lib/schemacop/v2/node_supporting_field.rb".freeze, "lib/schemacop/v2/node_supporting_type.rb".freeze, "lib/schemacop/v2/node_with_block.rb".freeze, "lib/schemacop/v2/validator/array_validator.rb".freeze, "lib/schemacop/v2/validator/boolean_validator.rb".freeze, "lib/schemacop/v2/validator/float_validator.rb".freeze, "lib/schemacop/v2/validator/hash_validator.rb".freeze, "lib/schemacop/v2/validator/integer_validator.rb".freeze, "lib/schemacop/v2/validator/nil_validator.rb".freeze, "lib/schemacop/v2/validator/number_validator.rb".freeze, "lib/schemacop/v2/validator/object_validator.rb".freeze, "lib/schemacop/v2/validator/string_validator.rb".freeze, "lib/schemacop/v2/validator/symbol_validator.rb".freeze, "lib/schemacop/v3.rb".freeze, "lib/schemacop/v3/all_of_node.rb".freeze, "lib/schemacop/v3/any_of_node.rb".freeze, "lib/schemacop/v3/array_node.rb".freeze, "lib/schemacop/v3/binary_node.rb".freeze, "lib/schemacop/v3/boolean_node.rb".freeze, "lib/schemacop/v3/combination_node.rb".freeze, "lib/schemacop/v3/context.rb".freeze, "lib/schemacop/v3/dsl_scope.rb".freeze, "lib/schemacop/v3/global_context.rb".freeze, "lib/schemacop/v3/hash_node.rb".freeze, "lib/schemacop/v3/integer_node.rb".freeze, "lib/schemacop/v3/is_not_node.rb".freeze, "lib/schemacop/v3/node.rb".freeze, "lib/schemacop/v3/node_registry.rb".freeze, "lib/schemacop/v3/number_node.rb".freeze, "lib/schemacop/v3/numeric_node.rb".freeze, "lib/schemacop/v3/object_node.rb".freeze, "lib/schemacop/v3/one_of_node.rb".freeze, "lib/schemacop/v3/reference_node.rb".freeze, "lib/schemacop/v3/result.rb".freeze, "lib/schemacop/v3/string_node.rb".freeze, "lib/schemacop/v3/symbol_node.rb".freeze, "schemacop.gemspec".freeze, "test/lib/test_helper.rb".freeze, "test/schemas/nested/group.rb".freeze, "test/schemas/user.rb".freeze, "test/unit/schemacop/v2/casting_test.rb".freeze, "test/unit/schemacop/v2/collector_test.rb".freeze, "test/unit/schemacop/v2/custom_check_test.rb".freeze, "test/unit/schemacop/v2/custom_if_test.rb".freeze, "test/unit/schemacop/v2/defaults_test.rb".freeze, "test/unit/schemacop/v2/empty_test.rb".freeze, "test/unit/schemacop/v2/nil_dis_allow_test.rb".freeze, "test/unit/schemacop/v2/node_resolver_test.rb".freeze, "test/unit/schemacop/v2/short_forms_test.rb".freeze, "test/unit/schemacop/v2/types_test.rb".freeze, "test/unit/schemacop/v2/validator_array_test.rb".freeze, "test/unit/schemacop/v2/validator_boolean_test.rb".freeze, "test/unit/schemacop/v2/validator_float_test.rb".freeze, "test/unit/schemacop/v2/validator_hash_test.rb".freeze, "test/unit/schemacop/v2/validator_integer_test.rb".freeze, "test/unit/schemacop/v2/validator_nil_test.rb".freeze, "test/unit/schemacop/v2/validator_number_test.rb".freeze, "test/unit/schemacop/v2/validator_object_test.rb".freeze, "test/unit/schemacop/v2/validator_string_test.rb".freeze, "test/unit/schemacop/v2/validator_symbol_test.rb".freeze, "test/unit/schemacop/v3/all_of_node_test.rb".freeze, "test/unit/schemacop/v3/any_of_node_test.rb".freeze, "test/unit/schemacop/v3/array_node_test.rb".freeze, "test/unit/schemacop/v3/binary_node_test.rb".freeze, "test/unit/schemacop/v3/boolean_node_test.rb".freeze, "test/unit/schemacop/v3/global_context_test.rb".freeze, "test/unit/schemacop/v3/hash_node_test.rb".freeze, "test/unit/schemacop/v3/integer_node_test.rb".freeze, "test/unit/schemacop/v3/is_not_node_test.rb".freeze, "test/unit/schemacop/v3/node_test.rb".freeze, "test/unit/schemacop/v3/number_node_test.rb".freeze, "test/unit/schemacop/v3/object_node_test.rb".freeze, "test/unit/schemacop/v3/one_of_node_test.rb".freeze, "test/unit/schemacop/v3/reference_node_test.rb".freeze, "test/unit/schemacop/v3/string_node_test.rb".freeze, "test/unit/schemacop/v3/symbol_node_test.rb".freeze]
   s.homepage = "https://github.com/sitrox/schemacop".freeze
   s.licenses = ["MIT".freeze]

data/test/lib/test_helper.rb

@@ -96,6 +96,13 @@ class V3Test < SchemacopTest
     @schema = Schemacop::Schema3.new(type, **options, &block)
   end
 
+  # `\x80` is a UTF-8 continuation byte and invalid on its own, as it is in
+  # US-ASCII. Operations that decode the string (`blank?`, `match?`, `to_sym`)
+  # raise on it.
+  def invalid_string(encoding = 'UTF-8')
+    "abc\x80def".dup.force_encoding(encoding)
+  end
+
   def with_context(context, &block)
     Schemacop.with_context(context, &block)
   end

data/test/unit/schemacop/v3/array_node_test.rb

@@ -172,6 +172,26 @@ module Schemacop
         end
       end
 
+      def test_items_with_invalid_encoding
+        schema :array do
+          list :string
+        end
+
+        assert_validation ['foo', invalid_string, 'bar'] do
+          error '/[1]', 'String has invalid "UTF-8" encoding.'
+        end
+
+        schema :array, unique_items: true do
+          list :string
+        end
+
+        assert_validation [invalid_string, invalid_string] do
+          error '/', 'Array has duplicate items.'
+          error '/[0]', 'String has invalid "UTF-8" encoding.'
+          error '/[1]', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
       def test_single_item_tuple
         schema :array do
           str

data/test/unit/schemacop/v3/binary_node_test.rb

@@ -13,6 +13,14 @@ module Schemacop
         assert_json(type: :string, format: :binary)
       end
 
+      def test_invalid_encoding
+        schema :binary
+
+        # Binary data is not decoded, so any byte sequence is accepted.
+        assert_validation invalid_string
+        assert_cast invalid_string, invalid_string
+      end
+
       def test_required
         schema :binary, required: true
 

data/test/unit/schemacop/v3/hash_node_test.rb

@@ -49,6 +49,29 @@ module Schemacop
         end
       end
 
+      def test_parse_json_with_invalid_encoding
+        schema :hash, parse_json: true do
+          str! :name
+        end
+
+        assert_validation(%({"name":"foo"}))
+
+        # The invalid bytes survive parsing and are reported by the string node.
+        assert_validation(%({"name":"#{invalid_string}"})) do
+          error '/name', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_property_value_with_invalid_encoding
+        schema do
+          str! :foo, format: :integer
+        end
+
+        assert_validation(foo: invalid_string) do
+          error '/foo', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
       def test_additional_properties_false_by_default
         schema
         assert_validation({})
@@ -350,6 +373,98 @@ module Schemacop
         assert_cast({ id_foo: 1, id_bar: 2, value: 4 }, { id_foo: 1, id_bar: 2, value: 4 }.with_indifferent_access)
       end
 
+      def test_encoding_invalid_bytes_property_name
+        schema :hash, additional_properties: true, property_names: '^[a-z]+$'
+
+        assert_validation(invalid_string => 'bar') do
+          error '/', 'Property name "abc\x80def" does not match "^[a-z]+$".'
+        end
+      end
+
+      def test_encoding_invalid_bytes_pattern_property_name
+        schema additional_properties: false do
+          str?(/^foo_.*$/)
+        end
+
+        assert_validation(invalid_string => 'bar') do
+          error '/', 'Obsolete property "abc\x80def".'
+        end
+      end
+
+      def test_encoding_invalid_bytes_pattern_property_casting
+        schema ignore_obsolete_properties: true do
+          str?(/^foo_.*$/)
+        end
+
+        assert_validation(foo_bar: 'baz', invalid_string => 'bar')
+        assert_cast({ :foo_bar => 'baz', invalid_string => 'bar' }, { foo_bar: 'baz' }.with_indifferent_access)
+      end
+
+      def test_encoding_invalid_bytes_property_name_with_obsolete_allow_list
+        schema :hash, ignore_obsolete_properties: %i[obsolete_key] do
+          str? :foo
+        end
+
+        assert_validation(:foo => 'bar', :obsolete_key => 'baz', invalid_string => 'qux') do
+          error '/', 'Obsolete property "abc\x80def".'
+        end
+
+        schema :hash, ignore_obsolete_properties: [invalid_string] do
+          str? :foo
+        end
+
+        assert_validation(:foo => 'bar', invalid_string => 'qux')
+      end
+
+      def test_encoding_invalid_bytes_in_error_path
+        schema :hash do
+          add :string
+        end
+
+        assert_validation(invalid_string => invalid_string) do
+          error '/abc�def', 'String has invalid "UTF-8" encoding.'
+        end
+
+        # The message is composed of the path and the error, so the path must
+        # not carry bytes the composition cannot handle.
+        assert_raises_with_message Exceptions::ValidationError,
+                                   '/abc�def: String has invalid "UTF-8" encoding.' do
+          @schema.validate!(invalid_string => invalid_string)
+        end
+      end
+
+      def test_encoding_invalid_bytes_dependency
+        schema :hash do
+          str? :credit_card
+          str? :billing_address
+
+          dep :credit_card, :billing_address
+        end
+
+        assert_validation(credit_card: invalid_string) do
+          error '/credit_card', 'String has invalid "UTF-8" encoding.'
+          error '/', 'Missing property "billing_address" because "credit_card" is given.'
+        end
+
+        # A target with an invalid byte sequence is given, not blank.
+        assert_validation(credit_card: 'foo', billing_address: invalid_string) do
+          error '/billing_address', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_incompatible_dependency
+        schema :hash do
+          str? :credit_card
+          str? :billing_address
+
+          dep :credit_card, :billing_address
+        end
+
+        assert_validation(credit_card: 'foo'.encode('UTF-16')) do
+          error '/', 'Missing property "billing_address" because "credit_card" is given.'
+        end
+      end
+
       def test_defaults
         schema do
           str? :first_name, default: 'John'
@@ -1005,6 +1120,33 @@ module Schemacop
         assert_cast({ foo: 42 }, { bar: 42 }.with_indifferent_access)
       end
 
+      def test_as_option_with_additional_properties
+        schema do
+          str? :foo, as: :bar
+          add :string
+        end
+
+        assert_cast({ foo: 'baz' }, { bar: 'baz' }.with_indifferent_access)
+        assert_cast({ foo: 'baz', other: 'qux' }, { bar: 'baz', other: 'qux' }.with_indifferent_access)
+
+        schema :hash, additional_properties: true do
+          str? :foo, as: :bar
+        end
+
+        assert_cast({ foo: 'baz' }, { bar: 'baz' }.with_indifferent_access)
+        assert_cast({ foo: 'baz', other: 42 }, { bar: 'baz', other: 42 }.with_indifferent_access)
+      end
+
+      def test_as_option_with_pattern_property
+        schema do
+          str? :foo_bar, as: :bar, format: :integer
+          str?(/^foo_.*$/)
+        end
+
+        assert_cast({ foo_bar: '42' }, { bar: 42 }.with_indifferent_access)
+        assert_cast({ foo_bar: '42', foo_qux: 'x' }, { bar: 42, foo_qux: 'x' }.with_indifferent_access)
+      end
+
       def test_as_option_overriding
         schema :hash do
           int? :foo, as: :bar

data/test/unit/schemacop/v3/integer_node_test.rb

@@ -366,6 +366,20 @@ module Schemacop
         end
       end
 
+      def test_cast_str_with_invalid_encoding
+        schema :integer, cast_str: true
+
+        assert_validation(invalid_string) do
+          error '/', <<~PLAIN.strip
+            Matches 0 schemas but should match exactly 1:
+              - Schema 1:
+                - /: Invalid type, got type "String", expected "integer".
+              - Schema 2:
+                - /: String has invalid "UTF-8" encoding.
+          PLAIN
+        end
+      end
+
       def test_cast_str_required
         schema :integer, cast_str: true, required: true
 

data/test/unit/schemacop/v3/is_not_node_test.rb

@@ -25,6 +25,18 @@ module Schemacop
         end
       end
 
+      def test_invalid_encoding
+        schema :is_not do
+          str pattern: /\Aabc/
+        end
+
+        assert_validation('def')
+
+        # A string with an invalid byte sequence matches no pattern, so it does
+        # not match the inner schema either.
+        assert_validation(invalid_string)
+      end
+
       def test_required
         schema :is_not, required: true do
           int minimum: 5

data/test/unit/schemacop/v3/object_node_test.rb

@@ -15,6 +15,14 @@ module Schemacop
         assert_json({})
       end
 
+      def test_invalid_encoding
+        schema :object, classes: [String]
+
+        # An object is only checked for its class, never decoded.
+        assert_validation invalid_string
+        assert_cast invalid_string, invalid_string
+      end
+
       def test_required_with_no_types
         schema :object, required: true
 

data/test/unit/schemacop/v3/one_of_node_test.rb

@@ -260,6 +260,44 @@ module Schemacop
         assert_validation(true)
       end
 
+      def test_treat_blank_as_nil_with_invalid_encoding
+        schema :one_of, treat_blank_as_nil: true do
+          str
+          int
+        end
+
+        # A string with an invalid byte sequence is not blank, so it is matched
+        # against the items rather than treated as nil.
+        assert_validation invalid_string do
+          error '/', <<~PLAIN.strip
+            Matches 0 schemas but should match exactly 1:
+              - Schema 1:
+                - /: String has invalid "UTF-8" encoding.
+              - Schema 2:
+                - /: Invalid type, got type "String", expected "integer".
+          PLAIN
+        end
+      end
+
+      def test_treat_blank_as_nil_with_incompatible_encoding
+        schema :one_of, treat_blank_as_nil: true do
+          boo
+          str format: :boolean
+        end
+
+        assert_validation ''.encode('UTF-16')
+
+        assert_validation 'true'.encode('UTF-16') do
+          error '/', <<~PLAIN.strip
+            Matches 0 schemas but should match exactly 1:
+              - Schema 1:
+                - /: Invalid type, got type "String", expected "boolean".
+              - Schema 2:
+                - /: String does not match format "boolean".
+          PLAIN
+        end
+      end
+
       # With cast_str as default option, int gets wrapped in a OneOfNode containing
       # [IntegerNode, StringNode(format: :integer)]. When combined with a sibling str
       # node in one_of, numeric-looking strings like "1" match both the wrapped int

data/test/unit/schemacop/v3/string_node_test.rb

@@ -323,6 +323,10 @@ module Schemacop
           error '/', 'String does not match format "integer".'
         end
 
+        assert_validation "32\ntest" do
+          error '/', 'String does not match format "integer".'
+        end
+
         assert_cast(nil, nil)
         assert_cast('2234', 2234)
         assert_cast('-1', -1)
@@ -516,9 +520,11 @@ module Schemacop
       end
 
       def test_format_custom
+        formatters_was = Schemacop.string_formatters.dup
+
         Schemacop.register_string_formatter(
           :integer_tuple_list,
-          pattern: /^(-?[0-9]+):(-?[0-9]+)(,(-?[0-9]+):(-?[0-9]+))*$/,
+          pattern: /\A(-?[0-9]+):(-?[0-9]+)(,(-?[0-9]+):(-?[0-9]+))*\z/,
           handler: proc do |value|
             value.split(',').map { |t| t.split(':').map(&:to_i) }
           end
@@ -539,8 +545,55 @@ module Schemacop
           error '/', 'String does not match format "integer-tuple-list".'
         end
 
+        assert_validation "1:5\nsd sfdij soidf" do
+          error '/', 'String does not match format "integer-tuple-list".'
+        end
+
         assert_cast nil, nil
         assert_cast '1:2,3:4,5:-6', [[1, 2], [3, 4], [5, -6]]
+      ensure
+        Schemacop.string_formatters = formatters_was
+      end
+
+      # A format pattern must be anchored with \A and \z: ^ and $ match the
+      # start and the end of any line, so a multi-line string would pass the
+      # validation and be handed to the cast handler.
+      def test_format_multiline
+        values = {
+          date:         '2020-01-13',
+          date_time:    '2018-11-13T20:20:39Z',
+          time:         '20:30:39Z',
+          email:        'support@example.com',
+          mailbox:      '<support@example.com>',
+          boolean:      'true',
+          integer:      '23425',
+          number:       '2.34',
+          integer_list: '1,2,3',
+          ipv4:         '192.168.0.1',
+          ipv4_cidr:    '192.168.0.1/24',
+          ipv6:         '2001:db8::1'
+        }
+
+        assert_equal Schemacop.string_formatters.reject { |_, f| f[:pattern].nil? }.keys.sort,
+                     values.keys.map { |format| format.to_s.dasherize.to_sym }.sort,
+                     'Every format with a pattern must be covered here'
+
+        values.each do |format, value|
+          name = format.to_s.dasherize.to_sym
+
+          schema :string, format: format
+
+          assert_validation value
+
+          ["#{value}\nfoo", "foo\n#{value}", "#{value}\n"].each do |multiline|
+            refute Schemacop.string_formatters[name][:pattern].match?(multiline),
+                   "Format #{name} matches the multi-line value #{multiline.inspect}"
+
+            assert_validation multiline do
+              error '/', "String does not match format #{name.to_s.inspect}."
+            end
+          end
+        end
       end
 
       def test_enum
@@ -781,7 +834,6 @@ module Schemacop
       def test_encoding_invalid_bytes
         schema :string, encoding: 'UTF-8'
 
-        invalid_string = "abc\x80def".force_encoding('UTF-8')
         assert_validation invalid_string do
           error '/', 'String has invalid "UTF-8" encoding.'
         end
@@ -790,12 +842,140 @@ module Schemacop
       def test_encoding_invalid_bytes_without_specific_encoding
         schema :string
 
-        invalid_string = "abc\x80def".force_encoding('UTF-8')
         assert_validation invalid_string do
           error '/', 'String has invalid "UTF-8" encoding.'
         end
       end
 
+      def test_encoding_invalid_bytes_us_ascii
+        schema :string
+
+        assert_validation invalid_string('US-ASCII') do
+          error '/', 'String has invalid "US-ASCII" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_and_encoding_mismatch
+        schema :string, encoding: 'UTF-8'
+
+        assert_validation invalid_string('US-ASCII') do
+          error '/', 'String has encoding "US-ASCII" but must be "UTF-8".'
+          error '/', 'String has invalid "US-ASCII" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_format
+        schema :string, format: :integer
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_format_options
+        schema :string, format: :integer, format_options: { minimum: 5 }
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_format_without_pattern
+        schema :string, format: :symbol
+
+        assert_validation :foo.to_s
+
+        # The symbol formatter has no pattern to fail on, and its handler calls
+        # "to_sym", which raises on an invalid byte sequence.
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_incompatible_with_pattern
+        schema :string, pattern: /^ü+$/
+
+        assert_validation 'üü'
+        assert_validation 'üü'.encode('ISO-8859-1') do
+          error '/', 'String does not match pattern "^ü+$".'
+        end
+      end
+
+      def test_encoding_incompatible_with_format
+        schema :string, format: :integer
+
+        assert_validation '42'
+
+        # UTF-16 is a dummy encoding and cannot be matched against a pattern in
+        # any other encoding, so the string does not match, valid as it looks.
+        assert_validation '42'.encode('UTF-16') do
+          error '/', 'String does not match format "integer".'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_pattern
+        schema :string, pattern: /\Aabc.*\z/
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_allow_blank_false
+        schema :string, allow_blank: false
+
+        assert_validation invalid_string do
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_incompatible_with_allow_blank_false
+        schema :string, allow_blank: false
+
+        assert_validation '42'.encode('UTF-16')
+        assert_validation ''.encode('UTF-16') do
+          error '/', 'String is blank but must not be blank!'
+        end
+      end
+
+      def test_encoding_binary_has_no_invalid_bytes
+        schema :string
+
+        # Every byte sequence is valid in ASCII-8BIT.
+        assert_validation invalid_string('ASCII-8BIT')
+      end
+
+      def test_encoding_invalid_bytes_with_length
+        schema :string, min_length: 20, max_length: 30
+
+        # The length checks do not decode the string, so they are still
+        # reported.
+        assert_validation invalid_string do
+          error '/', 'String is 7 characters long but must be at least 20.'
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
+      def test_encoding_incompatible_with_length
+        schema :string, max_length: 2
+
+        assert_validation '42'
+
+        # A dummy encoding has no characters, so "size" counts bytes.
+        assert_validation '42'.encode('UTF-16') do
+          error '/', 'String is 6 characters long but must be at most 2.'
+        end
+      end
+
+      def test_encoding_invalid_bytes_with_enum
+        schema :string, enum: ['foo']
+
+        assert_validation invalid_string do
+          error '/', 'Value not included in enum ["foo"].'
+          error '/', 'String has invalid "UTF-8" encoding.'
+        end
+      end
+
       def test_encoding_validate_self
         assert_raises_with_message Exceptions::InvalidSchemaError,
                                    'Option "encoding" must be a string or an array of strings.' do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: schemacop
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Sitrox
 bindir: bin
 cert_chain: []
-date: 2026-05-12 00:00:00.000000000 Z
+date: 2026-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -164,7 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.2
+rubygems_version: 4.0.8
 specification_version: 4
 summary: Schemacop validates ruby structures consisting of nested hashes and arrays
   against simple schema definitions.