schemacop 3.0.39 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5265f8c948ca9f0d23aa7e13ff78a5a980ce12ccd16c6fd1dae4e8ec6a30b833
-  data.tar.gz: 77177403eccb133730a9359172c6d37362d2d76184a2758131bcd35fe5869f0a
+  metadata.gz: f790c910d2c32accea93c9f4e67b85c80ababfbaca2b64930d7e380a65125d9e
+  data.tar.gz: ae3f22c58697112408efde125190a0cd8518199ceb8b47b65094e289d9e8769d
 SHA512:
-  metadata.gz: 306a17bfebac65db3f0c7fbd37f2b5d0fa3c44b26c6217732241fa8cd43455a552a07f21327c805d421c0a2649f8b1b936b8063d9cf5b97673e416aea3dff8b6
-  data.tar.gz: 64f2e2a148374b811fb4ac251606b25c48be802a1255e3dd72389aa2f4250f59695dba9b20b8cc62f48a9e646ea45d6cc9c9aeacc216b4704300b3864fa1701c
+  metadata.gz: b3f20de721d5e94f4bbb1504292c8ecd7136ae8468e8fde9d0885e9503aee4c6f950e7bd888ea50067d0dbf40c3dd0e36ab12d2ee674143a28405bd3c70bfe2f
+  data.tar.gz: efd82ce7677ee0c3d5031af98997840cd6cf38a3aa2337e68ead04e383add88e32d29f15d08ad0739e47691c48299f329c547677abd6aca1118a29fe6308a4e4

data/.github/workflows/ruby.yml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ['2.6.2', '2.7.1', '3.0.1', '3.1.0', '3.2.0', '3.3.0', '3.4.0']
+        ruby-version: ['3.2.0', '3.3.0', '3.4.0', '4.0.0']
 
     steps:
     - uses: actions/checkout@v2

data/.rubocop.yml

@@ -10,7 +10,7 @@ AllCops:
     - 'locale/translations.rb'
     - 'lib/scratch.rb'
     - 'schemacop.gemspec'
-
+  SuggestExtensions: false
   DisplayCopNames: true
 
 Style/SignalException:
@@ -108,4 +108,7 @@ Style/CaseLikeIf:
   Enabled: false
 
 Lint/EmptyClass:
+  Enabled: false
+
+Lint/RedundantRequireStatement:
   Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,92 @@
 # 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
+  a string has one of the specified encodings. Accepts a single encoding name or
+  an array of encoding names (e.g. `encoding: 'UTF-8'` or
+  `encoding: %w[UTF-8 US-ASCII]`).
+
+  Internal reference: `#143271`.
+
+* All strings are now validated for valid encoding (via `valid_encoding?`),
+  regardless of whether the `encoding` option is set. Strings with invalid byte
+  sequences for their declared encoding will now produce a validation error.
+
+  Internal reference: `#143271`.
+
+* Update RuboCop from 1.24.1 to 1.69.2.
+
+* Drop support for all EOL Rubies (2.6.2, 2.7.1, 3.0.1, 3.1.0)
+
+* Fix `cast_str` default option causing incorrect casting and validation errors
+  when used with combination nodes and array tuples. Numeric-looking strings
+  (e.g. `"1"`) were incorrectly cast to integers in schemas where a string type
+  was also valid. With this fix, `cast_str` only activates when the value cannot
+  be matched natively by another sibling schema.
+
+  Internal reference: `#149255`.
+
 ## 3.0.39 (2026-03-26)
 
 * Add `BinaryNode` for validating binary data fields such as file uploads.

data/Gemfile

@@ -9,5 +9,5 @@ gem 'minitest'
 gem 'minitest-reporters'
 gem 'pry'
 gem 'rake'
-gem 'rubocop', '1.24.1'
+gem 'rubocop', '1.69.2'
 gem 'simplecov', '0.21.2'

data/README.md

@@ -12,13 +12,14 @@ use in conjunction with [OpenAPI](https://swagger.io/specification/).
 
 Schemacop is tested with the following ruby versions:
 
-* 2.6.2
-* 2.7.1
-* 3.0.1
-* 3.1.0
-* 3.2.0
-* 3.3.0
-* 3.4.0
+| Schemacop | Ruby                                            |
+|:----------|:------------------------------------------------|
+| >= 3.1.0  | 3.2.0, 3.3.0, 3.4.0, 4.0.0                      |
+| >= 3.0.31 | 2.6.2, 2.7.1, 3.0.1, 3.1.0, 3.2.0, 3.3.0, 3.4.0 |
+| >= 3.0.29 | 2.6.2, 2.7.1, 3.0.1, 3.1.0, 3.2.0, 3.3.0        |
+| >= 3.0.23 | 2.6.2, 2.7.1, 3.0.1, 3.1.0, 3.2.0               |
+| >= 3.0.17 | 2.6.2, 2.7.1, 3.0.1, 3.1.0                      |
+| <= 3.0.16 | 2.6.2, 2.7.1, 3.0.1                             |
 
 Other ruby versions might work but are not covered by our automated tests.
 

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
@@ -224,6 +233,23 @@ transformed into various types.
   By default, blank strings are allowed and left as they are when casted (e.g.
   the string `''` is valid). If you want to disallow blank strings, set this
   option to `false`.
+* `encoding`
+  Validates the encoding of the string. Accepts a single encoding name or an
+  array of encoding names (e.g. `encoding: 'UTF-8'` or
+  `encoding: %w[UTF-8 US-ASCII]`). See `Encoding.name_list` for all available
+  encoding names.
+
+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. 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
 
@@ -286,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
@@ -927,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.0.39
+3.1.1

data/lib/schemacop/schema3.rb

@@ -1,8 +1,8 @@
 module Schemacop
   class Schema3 < BaseSchema
-    def initialize(*args, **kwargs, &block)
+    def initialize(...)
       super()
-      @root = V3::Node.create(*args, **kwargs, &block)
+      @root = V3::Node.create(...)
     end
 
     # Validate data for the defined Schema

data/lib/schemacop/v2/node.rb

@@ -88,7 +88,7 @@ module Schemacop
 
         if option?(:cast) && self.class.klasses.size > 1
           fail Exceptions::InvalidSchemaError,
-               "Casting is only allowed for single-value datatypes, but type #{self.class.inspect} has classes "\
+               "Casting is only allowed for single-value datatypes, but type #{self.class.inspect} has classes " \
                "#{self.class.klasses.map(&:inspect)}."
         end
       end

data/lib/schemacop/v2/validator/string_validator.rb

@@ -7,7 +7,7 @@ module Schemacop
       option :max
 
       def initialize(options = {})
-        super(options)
+        super
 
         validate_options!
       end

data/lib/schemacop/v3/any_of_node.rb

@@ -5,6 +5,19 @@ module Schemacop
         :anyOf
       end
 
+      protected
+
+      def matches(data)
+        all_matches = super
+        if all_matches.size > 1
+          non_wrappers = all_matches.reject(&:cast_str_wrapper?)
+          return non_wrappers if non_wrappers.any?
+        end
+        all_matches
+      end
+
+      public
+
       def _validate(data, result:)
         super_data = super
         return if super_data.nil?

data/lib/schemacop/v3/array_node.rb

@@ -156,7 +156,7 @@ module Schemacop
         result = []
 
         value.each_with_index do |value_item, index|
-          if cont_item.present? && item_matches?(cont_item, value_item)
+          if cont_item.present? && !cont_item.cast_str_wrapper? && item_matches?(cont_item, value_item)
             result << cont_item.cast(value_item)
           elsif list?
             result << list_item.cast(value_item)
@@ -168,8 +168,7 @@ module Schemacop
                 result << value_item
               end
             else
-              item = item_for_data(value_item)
-              result << item.cast(value_item)
+              result << items[index].cast(value_item)
             end
           else
             result << value_item

data/lib/schemacop/v3/global_context.rb

@@ -97,7 +97,7 @@ module Schemacop
           fail "Schema #{path.inspect} does not define any schema."
         when 1
           if @schemas.include?(virtual_path)
-            fail "Schema #{virtual_path.to_s.inspect} is defined in both load paths "\
+            fail "Schema #{virtual_path.to_s.inspect} is defined in both load paths " \
                  "#{@load_paths_by_schemas[virtual_path].inspect} and #{load_path.inspect}."
           end
 

data/lib/schemacop/v3/hash_node.rb

@@ -65,8 +65,8 @@ module Schemacop
         end
 
         json = {}
-        json[:properties] = properties.values.map { |p| [p.name, p.as_json] }.to_h if properties.any?
-        json[:patternProperties] = pattern_properties.values.map { |p| [V3.sanitize_exp(p.name), p.as_json] }.to_h if pattern_properties.any?
+        json[:properties] = properties.values.to_h { |p| [p.name, p.as_json] } if properties.any?
+        json[:patternProperties] = pattern_properties.values.to_h { |p| [V3.sanitize_exp(p.name), p.as_json] } if pattern_properties.any?
 
         # In schemacop, by default, additional properties are not allowed,
         # the users explicitly need to enable additional properties
@@ -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|
@@ -300,19 +306,15 @@ module Schemacop
       protected
 
       def as_json_with_inline_refs(properties, pattern_properties)
-        all_of = []
-
         # Add each inline ref
-        @inline_refs.each do |inline_ref|
-          all_of << inline_ref.as_json
-        end
+        all_of = @inline_refs.map(&:as_json)
 
         # Add own properties schema if any direct properties exist
         if properties.any? || pattern_properties.any?
           own_schema = {}
           own_schema[:type] = :object
-          own_schema[:properties] = properties.values.map { |p| [p.name, p.as_json] }.to_h if properties.any?
-          own_schema[:patternProperties] = pattern_properties.values.map { |p| [V3.sanitize_exp(p.name), p.as_json] }.to_h if pattern_properties.any?
+          own_schema[:properties] = properties.values.to_h { |p| [p.name, p.as_json] } if properties.any?
+          own_schema[:patternProperties] = pattern_properties.values.to_h { |p| [V3.sanitize_exp(p.name), p.as_json] } if pattern_properties.any?
 
           if options[:additional_properties].is_a?(TrueClass)
             own_schema[:additionalProperties] = true

data/lib/schemacop/v3/node.rb

@@ -45,6 +45,7 @@ module Schemacop
             self.node node
             str format: format, format_options: options
           end
+          node.instance_variable_set(:@cast_str_wrapper, true)
         end
 
         return node
@@ -136,6 +137,10 @@ module Schemacop
         (parent&.schemas || {}).merge(@schemas)
       end
 
+      def cast_str_wrapper?
+        !!@cast_str_wrapper
+      end
+
       def required?
         @required
       end

data/lib/schemacop/v3/numeric_node.rb

@@ -30,7 +30,7 @@ module Schemacop
           attrs -= %i[exclusive_minimum exclusive_maximum]
         end
 
-        super attrs, json
+        super
       end
 
       def _validate(data, result:)
@@ -102,7 +102,7 @@ module Schemacop
           fail 'Option "minimum" can\'t be greater than "maximum".'
         end
 
-        if options[:exclusive_minimum] && options[:exclusive_maximum]\
+        if options[:exclusive_minimum] && options[:exclusive_maximum] \
            && options[:exclusive_minimum] > options[:exclusive_maximum]
           fail 'Option "exclusive_minimum" can\'t be greater than "exclusive_maximum".'
         end

data/lib/schemacop/v3/object_node.rb

@@ -12,7 +12,7 @@ module Schemacop
       protected
 
       def allowed_types
-        @classes.map { |c| [c, c.name] }.to_h
+        @classes.to_h { |c| [c, c.name] }
       end
 
       def init

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
@@ -23,12 +23,25 @@ module Schemacop
         return item.cast(value)
       end
 
+      protected
+
+      def matches(data)
+        all_matches = super
+        if all_matches.size > 1
+          non_wrappers = all_matches.reject(&:cast_str_wrapper?)
+          return non_wrappers if non_wrappers.any?
+        end
+        all_matches
+      end
+
+      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
 
-        super_data = super(data, result: result)
+        super_data = super
         return if super_data.nil?
 
         matches = matches(super_data)

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

@@ -8,7 +8,7 @@ module Schemacop
       ].freeze
 
       def self.allowed_options
-        super + ATTRIBUTES + %i[format_options pattern allow_blank]
+        super + ATTRIBUTES + %i[format_options pattern allow_blank encoding]
       end
 
       def allowed_types
@@ -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,13 +44,29 @@ module Schemacop
           result.error "String is #{length} characters long but must be at most #{options[:max_length]}."
         end
 
+        # Validate encoding matches #
+        if options[:encoding]
+          allowed_encodings = Array(options[:encoding])
+          unless allowed_encodings.include?(super_data.encoding.name)
+            result.error "String has encoding #{super_data.encoding.name.inspect} but must be #{allowed_encodings.map(&:inspect).join(' or ')}."
+          end
+        end
+
+        # 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 super_data.match?(pattern)
+          unless V3.match?(pattern, super_data)
             result.error "String does not match pattern #{V3.sanitize_exp(pattern).inspect}."
           end
         end
@@ -59,7 +75,7 @@ module Schemacop
         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])
@@ -109,6 +125,18 @@ module Schemacop
           fail 'Option "min_length" can\'t be greater than "max_length".'
         end
 
+        if options[:encoding]
+          unless options[:encoding].is_a?(String) || (options[:encoding].is_a?(Array) && options[:encoding].all? { |e| e.is_a?(String) })
+            fail 'Option "encoding" must be a string or an array of strings.'
+          end
+
+          Array(options[:encoding]).each do |encoding|
+            Encoding.find(encoding)
+          rescue ArgumentError
+            fail "Option \"encoding\" contains unknown encoding #{encoding.inspect}."
+          end
+        end
+
         if options[:pattern]
           unless options[:pattern].is_a?(String) || options[:pattern].is_a?(Regexp)
             fail 'Option "pattern" must be a string or Regexp.'

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)