schemacop 3.0.34 → 3.0.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 818a611a08d135cb5fb9c691a101472133c2313e5536675b62af795b01a56fbb
-  data.tar.gz: bea474ef2808294b83597bab07b076103b5ddddbe0d4aa2164bbed779f2cc130
+  metadata.gz: 9494f9a5a921664fae74b99ecba0830775d160ae91250465b4b88ba1d1fdf970
+  data.tar.gz: 2263f93913342b872ac56c52ddd65dd6c34f34711d3624c52c6ffc2d5a9a516a
 SHA512:
-  metadata.gz: f815986a0a382961c35445d710217a7af8bf9937fe6e137852e4c54c95bc9550b6796aa610f29e2b06aacd277e99eb2e19039bde2d8e1b6c0c5d27578db6b2a0
-  data.tar.gz: 0db3deb0605ae6a1315e91a58ca1beebfd74aabe7be9488df320736d1077c54ba993c4705b4a8f4b63c8adda3daf57c5a3e6b46639127daf9435a8e1b45544a1
+  metadata.gz: 3712232ba9d867f723ee462d80db875d6e0adbd6cd0579d798908df58f9fd9b5448389e2cc9829fe979bdcd972efa209a4b2ae6a27766d8d7884fa3a7189c4ab
+  data.tar.gz: fd5c87120fb0c2d1a1e13122013b08d902d37a32154d1196385ad6f2fb5fec28b54c0170f129533c7ce116ccadd13c7c653832f2102cfc4c63da62257170ee3a

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Change log
 
+## 3.0.36 (2026-01-05)
+
+* Fix `v3_default_options` not being applied when schemas are eager loaded in
+  production mode. The Railtie now explicitly loads `config/schemacop.rb`
+  during initialization, before eager loading schemas. This ensures that
+  default options like `cast_str` are applied to all schemas.
+
+  For Rails applications, place your Schemacop configuration in
+  `config/schemacop.rb` (not in the `initializers/` subdirectory) to benefit
+  from this fix. Configuration in `config/initializers/schemacop.rb` will
+  continue to work in development mode but will not be applied to eager-loaded
+  schemas in production mode (same behavior as in 3.0.35 and earlier).
+
+  Internal reference: `#144209`.
+
+* Fix test compatibility with Ruby 3.2+ by updating JSON parse error regex
+  patterns to match the new error message format introduced in Ruby 3.2.
+
+## 3.0.35 (2025-07-31)
+
+* Add option `max_precision` to `number` nodes for Schemacop V3 schemas to validate
+  the maximum number of decimal places for `Float` and `BigDecimal` values
+
 ## 3.0.34 (2025-05-27)
 
 * Adapt string format `number` to cast to `Integer` instead of to a `Float` if

data/README_V2.md

@@ -61,7 +61,7 @@ gem 'schemacop'
 ## Basics
 
 Since there is no explicit typing in Ruby, it can be hard to make sure that a
-method is recieving exactly the right kind of data it needs. The idea of this
+method is receiving exactly the right kind of data it needs. The idea of this
 gem is to define a schema at boot time that will validate the data being passed
 around at runtime. Those two steps look as follows:
 
@@ -84,7 +84,7 @@ my_schema.validate!(
 `validate!` will fail if the data given to it does not match what was specified
 in the schema.
 
-### Type lines vs. Field lines
+### Type Lines vs. Field Lines
 
 Schemacop uses a DSL (domain-specific language) to let you describe your
 schemas. We distinguish between two kinds of identifiers:
@@ -309,7 +309,7 @@ end
 You might find the notation cumbersome, and you'd be right to say so. Luckily
 there are plenty of short forms available which we will see below.
 
-#### Handling hashes with indifferent access
+#### Handling Hashes with Indifferent Access
 
 Schemacop has special handling for objects of the class
 `ActiveSupport::HashWithIndifferentAccess`: You may specify the keys as symbols
@@ -403,12 +403,12 @@ The following types are supported by Schemacop by default:
 All types support the options `if` and `check` (see the section about Type Lines
 above).
 
-## Short forms
+## Short Forms
 
 For convenience, the following short forms may be used (and combined if
 possible).
 
-### Passing a type to a Field Line or schema
+### Passing a Type to a Field Line or Schema
 
 Instead of adding a Type Line in the block of a Field Line, you can omit `do
 type ... end` and directly write the type after the key of the field.
@@ -444,7 +444,7 @@ Schema.new(:string, min: 2, max: 5)
 This means that the data given to the schema must be a String that is between 2
 and 5 characters long.
 
-### Passing multiple types at once
+### Passing Multiple Types at Once
 
 You can specify several types at once by putting them in an array.
 
@@ -522,7 +522,7 @@ Note that this does not allow you to specify any options for the hash itself.
 You still need to specify `:hash` as a type if you want to pass any options to
 the hash (i.e. a `default`).
 
-### Shortform for subtypes
+### Shortform for Subtypes
 
 In case of nested arrays, you can group all Type Lines to a single one.
 
@@ -638,14 +638,14 @@ Schema.new do
 end
 ```
 
-### Required data points
+### Required Data Points
 
 Note that any *required* validation is done before applying the defaults. If you
 specify a `req` field, it must always be given, no matter if you have specified
 a default or not. Therefore, specifying `req` fields do not make sense in
 conjunction with defaults, as the default is always ignored.
 
-## Type casting
+## Type Casting
 
 Starting from version 2.4.0, Schemacop allows you to specify type castings that
 can alter the validated data. Consider the following:
@@ -663,7 +663,7 @@ Note that Schemacop never modifies the data you pass to it. If you want to
 benefit from Schemacop-applied castings, you need to access the cloned, modified
 data returned by `validate` or `validate!`.
 
-### Specifying type castings
+### Specifying Type Castings
 
 Type castings can be specified using two forms: Either as a hash or as an array.
 While using an array only allows you to specify the supported source types to be
@@ -689,7 +689,7 @@ Schema.new do
 end
 ```
 
-### Built-in casters
+### Built-in Casters
 
 Schemacop comes with the following casters:
 
@@ -702,7 +702,7 @@ an error if casted to an Integer. When casting float values and strings
 containing float values to integers, the decimal places will be discarded
 however.
 
-### Execution order
+### Execution Order
 
 The casting is done *before* the options `if` and `check` are evaluated.
 Example:
@@ -748,7 +748,7 @@ Schemacop will throw one of the following checked exceptions:
   This exception is thrown when the given data does not comply with the given
   schema definition.
 
-## Known limitations
+## Known Limitations
 
 * Schemacop does not yet allow cyclic structures with infinite depth.
 

data/README_V3.md

@@ -1,4 +1,4 @@
-# Schemacop schema V3
+# Schemacop Schema V3
 
 ## Table of Contents
 
@@ -282,11 +282,11 @@ transformed into various types.
 #### Custom Formats
 
 You can also implement your custom formats or override the behavior of the
-standard formats. This can be done in the initializer configuration (in case of
-a Rails appliation):
+standard formats. For Rails applications, this can be done in
+`config/schemacop.rb`:
 
 ```ruby
-# config/initializers/schemacop.rb
+# config/schemacop.rb
 Schemacop.register_string_formatter(
   :character_array,                        # Formatter name
   pattern: /^[a-zA-Z](,[a-zA-Z])*/,        # Regex pattern for validation
@@ -424,7 +424,7 @@ and subclasses are valid:
 * `Rational`
 * `BigDecimal`
 
-As some subclasses of `Numeric`, such as `Complex` don't support all required oeprations,
+As some subclasses of `Numeric`, such as `Complex` don't support all required operations,
 only the above list is supported. If you need support for additional number classes, please
 contact the Gem maintainers.
 
@@ -445,6 +445,10 @@ With the various available options, validations on the value of the number can b
 * `multiple_of`
   The received number has to be a multiple of the given number for the validation to
   pass.
+* `max_precision`
+  Defines the maximum number of digits after the decimal point for `Float` and 
+  `BigDecimal` values. Must be a non-negative integer. When `nil` (default), no
+  precision validation is performed. Trailing zeros are ignored in the validation.
 * `cast_str`
   When set to `true`, this node also accepts strings that can be casted to a number, e.g.
   the values `'0.1'` or `'3.1415'`. Please note that you can only validate numbers which
@@ -483,12 +487,27 @@ schema.validate!(nil)         # => nil
 schema.validate!('')          # => nil
 ```
 
+With `max_precision`:
+
+```ruby
+# Validates that the input is a number with maximum 2 decimal places
+schema = Schemacop::Schema3.new(:number, max_precision: 2)
+schema.validate!(42)                   # => 42
+schema.validate!(42.5)                 # => 42.5
+schema.validate!(42.52)                # => 42.52
+schema.validate!(42.523)               # => Schemacop::Exceptions::ValidationError: /: Value must have a maximum precision of 2 digits after the decimal point.
+schema.validate!(BigDecimal('3.14'))   # => 0.314e1
+schema.validate!(BigDecimal('3.141'))  # => Schemacop::Exceptions::ValidationError: /: Value must have a maximum precision of 2 digits after the decimal point.
+schema.validate!(BigDecimal('3.140'))  # => 0.314e1 (trailing zeros are ignored)
+schema.validate!(1r)                   # => (1/1) (rational numbers are not affected)
+```
+
 Please note, that `nil` and blank strings are treated equally when using the `cast_str` option,
 and validating a blank string will return `nil`.
 If you need a value, use the `required` option:
 
 ```ruby
-schema = Schemacop::Schema3.new(:number, cast_str: true, minimum: 0.0, maximum: (50r), multiple_of: BigDecimal('0.5'), require: true)
+schema = Schemacop::Schema3.new(:number, cast_str: true, minimum: 0.0, maximum: (50r), multiple_of: BigDecimal('0.5'), required: true)
 schema.validate!('42.5')  # => 42.5
 schema.validate!(nil)     # => Schemacop::Exceptions::ValidationError: /: Value must be given.
 schema.validate!('')      # => Schemacop::Exceptions::ValidationError: /: Value must be given.
@@ -617,7 +636,7 @@ It consists of one or multiple values, which can be validated using arbitrary no
   must contain to pass the validation.
 
 * `unique_items`
-  This option specifies wether the items in the array must all be distinct from
+  This option specifies whether the items in the array must all be distinct from
   each other, or if there may be duplicate values. By default, this is false,
   i.e. duplicate values are allowed
 
@@ -685,13 +704,13 @@ schema.validate!([1, 2, 3]) # => Schemacop::Exceptions::ValidationError: /: At l
 schema.validate!([1, 3, 5]) # => [1, 3, 5]
 ```
 
-#### Specifying properties
+#### Specifying Properties
 
 Array nodes support a block in which you can specify the required array contents.
 The array nodes support either list validation, or tuple validation, depending on
 how you specify your array contents.
 
-##### List validation
+##### List Validation
 
 List validation validates a sequence of arbitrary length where each item matches
 the same schema. Unless you specify a `min_items` count on the array node, an
@@ -740,7 +759,7 @@ end
 # => Schemacop::Exceptions::InvalidSchemaError: You can only use "list" once.
 ```
 
-##### Tuple validation
+##### Tuple Validation
 
 On the other hand, tuple validation validates a sequence of fixed length, where
 each item has its own schema that it has to match. Here, the order of the items
@@ -831,8 +850,8 @@ Using the options `filter` and `reject`, arrays can be filtered. Filtering
 happens before validation. Both options behave in the same way, with the only
 difference being that `filter` uses a inclusive approach and `reject` an
 exclusive (see [filter](https://apidock.com/ruby/Array/filter) and
-[reject](https://apidock.com/ruby/Array/reject] in the Ruby API, as they behave
-in a similar manor).
+[reject](https://apidock.com/ruby/Array/reject) in the Ruby API, as they behave
+in a similar manner).
 
 You can either pass a Symbol which specifies the name of the method that is
 called on each array item:
@@ -932,11 +951,11 @@ It consists of key-value-pairs that can be validated using arbitrary nodes.
 
   Defaults to `false`.
 
-#### Specifying properties
+#### Specifying Properties
 
 Hash nodes support a block in which you can specify the required hash contents.
 
-##### Standard properties
+##### Standard Properties
 
 It supports all type nodes, but requires the suffix `?` or `!` for each
 property, which specifies whether a property is required (`!`) or optional
@@ -1059,7 +1078,7 @@ schema.validate!({foo: 1})      # => {"foo"=>1}
 schema.validate!({foo: 'bar'})  # => {"foo"=>"bar"}
 ```
 
-##### Pattern properties
+##### Pattern Properties
 
 In addition to symbols, property keys can also be a regular expression. Here,
 you may only use the optional `?` suffix for the property. This allows any
@@ -1079,7 +1098,7 @@ schema.validate!({id_foo: 1, id_bar: 2})  # => {"id_foo"=>1, "id_bar"=>2}
 schema.validate!({foo: 3})                # => Schemacop::Exceptions::ValidationError: /: Obsolete property "foo".
 ```
 
-##### Additional properties & property names
+##### Additional Properties & Property Names
 
 In addition to standard properties, you can allow the hash to contain
 additional, unspecified properties. By default, this is turned off if you have
@@ -1139,7 +1158,7 @@ schema.validate!({foo: :bar})       # => Schemacop::Exceptions::ValidationError:
 schema.validate!({Foo: :bar})       # => Schemacop::Exceptions::ValidationError: /: Property name :Foo does not match "^[a-z]+$". /Foo: Invalid type, got type "Symbol", expected "array".
 ```
 
-##### Ignoring obsolete properties
+##### Ignoring Obsolete Properties
 
 By enabling `ignore_obsolete_properties`, you can filter out any unspecified params,
 while still passing validation:
@@ -1540,7 +1559,7 @@ to use other data in the second context than in the first.
 
 ## External schemas
 
-Finally, Schemacop features the possibility to specify schemas in seperate
+Finally, Schemacop features the possibility to specify schemas in separate
 files.  This is especially useful is you have schemas in your application which
 are used multiple times throughout the application.
 
@@ -1563,7 +1582,7 @@ Where:
 * context schemas: Defined in the current context using `context.schema`
 * global schemas: Defined in a ruby file in the load path
 
-### External schemas in Rails applications
+### External Schemas in Rails Applications
 
 In Rails applications, your schemas are automatically eager-loaded from the load
 path `'app/schemas'` when your application is started, unless your application
@@ -1614,7 +1633,7 @@ schema.validate!({usr: {first_name: 'Joe', last_name: 'Doe', groups: [{name: 'fo
   # => {"usr"=>{"first_name"=>"Joe", "last_name"=>"Doe", "groups"=>[{"name"=>"foo"}, {"name"=>"bar"}]}}
 ```
 
-### External schemas in Non-Rails applications
+### External Schemas in Non-Rails Applications
 
 Usage in non-Rails applications is the same as with usage in Rails applications,
 however you might need to eager load the schemas yourself:
@@ -1632,11 +1651,24 @@ to eager-load them on start of your application / script.
 Using the setting `Schemacop.v3_default_options`, you can specify a hash
 containing default options that will be used for every schemacop node (options
 not supported by a particular node are automatically ignored). Options passed
-directly to a node still take precedence. The setting can be set in an
-initializer:
+directly to a node still take precedence.
+
+### Rails applications
+
+For Rails applications, configure default options in `config/schemacop.rb`
+(note: not in the `initializers/` subdirectory). This ensures that options are
+applied before schemas are eager loaded in production mode:
+
+```ruby
+# config/schemacop.rb
+Schemacop.v3_default_options = { cast_str: true }.freeze
+```
+
+### Non-Rails applications
+
+For non-Rails applications, set the options before loading any schemas:
 
 ```ruby
-# config/initializers/schemacop.rb
 Schemacop.v3_default_options = { cast_str: true }.freeze
 
 # Example schema: As cast_str is enabled in the default options, strings will

data/VERSION

@@ -1 +1 @@
-3.0.34
+3.0.36

data/lib/schemacop/railtie.rb

@@ -1,6 +1,13 @@
 module Schemacop
   class Railtie < Rails::Railtie
     initializer 'schemacop' do
+      # Load configuration
+      config_path = Rails.root.join('config', 'schemacop.rb')
+
+      if config_path.exist?
+        load config_path
+      end
+
       # Load global schemas
       unless Rails.env.development?
         V3::GlobalContext.eager_load!

data/lib/schemacop/v3/numeric_node.rb

@@ -8,6 +8,7 @@ module Schemacop
         multiple_of
         exclusive_minimum
         exclusive_maximum
+        max_precision
       ].freeze
 
       def self.allowed_options
@@ -58,12 +59,39 @@ module Schemacop
         if options[:multiple_of] && !compare_float((super_data % options[:multiple_of]), 0.0)
           result.error "Value must be a multiple of #{options[:multiple_of]}."
         end
+
+        # Validate max precision #
+        if options[:max_precision] && (super_data.is_a?(Float) || super_data.is_a?(BigDecimal))
+          # Convert to string and check decimal places
+          str = super_data.to_s
+          # For BigDecimal, remove the trailing '0' from the scientific notation if present
+          str = str.sub(/\.0e[+-]?\d+\z/, '.0') if super_data.is_a?(BigDecimal)
+
+          if (match = str.match(/\.(\d+)$/))
+            # Remove trailing zeros for more accurate precision check
+            decimal_part = match[1].sub(/0+\z/, '')
+            decimal_places = decimal_part.empty? ? 0 : decimal_part.length
+            if decimal_places > options[:max_precision]
+              result.error "Value must have a maximum precision of #{options[:max_precision]} digits after the decimal point."
+            end
+          end
+        end
       end
 
       def validate_self
         # Check that the options have the correct type
         ATTRIBUTES.each do |attribute|
           next if options[attribute].nil?
+
+          # Special handling for max_precision - must be an integer
+          if attribute == :max_precision
+            unless options[attribute].is_a?(Integer) && options[attribute] >= 0
+              fail 'Option "max_precision" must be a non-negative integer.'
+            end
+
+            next
+          end
+
           next unless allowed_types.keys.none? { |c| options[attribute].send(type_assertion_method, c) }
 
           collection = allowed_types.values.map { |t| "\"#{t}\"" }.uniq.sort.join(' or ')

data/schemacop.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: schemacop 3.0.34 ruby lib
+# stub: schemacop 3.0.36 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "schemacop".freeze
-  s.version = "3.0.34".freeze
+  s.version = "3.0.36".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 = "2025-05-27"
+  s.date = "2026-01-05"
   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/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/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/unit/schemacop/v3/array_node_test.rb

@@ -988,7 +988,7 @@ module Schemacop
         end
 
         assert_validation('{42]') do
-          error '/', /JSON parse error: "(\d+: )?unexpected token at '{42]'"\./
+          error '/', /JSON parse error: "((\d+: )?unexpected token at '{42]'|expected object key, got '42]' at line \d+ column \d+)"\./
         end
 
         assert_validation('"foo"') do

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

@@ -161,6 +161,104 @@ module Schemacop
           GlobalContext.instance.schema_for('user')
         end
       end
+
+      def test_v3_default_options_with_lazy_load
+        dir = Dir.mktmpdir
+        Schemacop.load_paths << dir
+        File.write(File.join(dir, 'test_schema.rb'), %(schema :integer))
+
+        Schemacop.v3_default_options = { cast_str: true }.freeze
+
+        schema = GlobalContext.instance.schema_for('test_schema')
+        result = schema.validate('42')
+
+        assert result.valid?, "Expected string '42' to be cast to integer 42, but got errors: #{result.errors}"
+        assert_equal 42, result.data
+      ensure
+        Schemacop.v3_default_options = {}
+      end
+
+      def test_v3_default_options_with_eager_load
+        dir = Dir.mktmpdir
+        Schemacop.load_paths << dir
+        File.write(File.join(dir, 'test_schema.rb'), %(schema :integer))
+
+        Schemacop.v3_default_options = { cast_str: true }.freeze
+
+        GlobalContext.instance.eager_load!
+        schema = GlobalContext.instance.schema_for('test_schema')
+        result = schema.validate('42')
+
+        assert result.valid?, "Expected string '42' to be cast to integer 42, but got errors: #{result.errors}"
+        assert_equal 42, result.data
+      ensure
+        Schemacop.v3_default_options = {}
+      end
+
+      def test_v3_default_options_with_nested_schema
+        dir = Dir.mktmpdir
+        Schemacop.load_paths << dir
+        File.write(File.join(dir, 'form_schema.rb'), <<~SCHEMA)
+          schema do
+            int! :age
+            str! :name
+          end
+        SCHEMA
+
+        Schemacop.v3_default_options = { cast_str: true }.freeze
+
+        schema = GlobalContext.instance.schema_for('form_schema')
+        result = schema.validate({ age: '25', name: 'John' })
+
+        assert result.valid?, "Expected string '25' to be cast to integer 25, but got errors: #{result.errors}"
+        assert_equal 25, result.data[:age]
+        assert_equal 'John', result.data[:name]
+      ensure
+        Schemacop.v3_default_options = {}
+      end
+
+      def test_v3_default_options_set_before_eager_load
+        dir = Dir.mktmpdir
+        Schemacop.load_paths << dir
+        File.write(File.join(dir, 'test_schema.rb'), %(schema :integer))
+
+        # Set default options BEFORE eager loading (simulates production mode)
+        Schemacop.v3_default_options = { cast_str: true }.freeze
+
+        GlobalContext.instance.eager_load!
+        schema = GlobalContext.instance.schema_for('test_schema')
+        result = schema.validate('42')
+
+        assert result.valid?, "Expected string '42' to be cast to integer 42, but got errors: #{result.errors}"
+        assert_equal 42, result.data
+      ensure
+        Schemacop.v3_default_options = {}
+      end
+
+      def test_v3_default_options_set_after_eager_load
+        dir = Dir.mktmpdir
+        Schemacop.load_paths << dir
+        File.write(File.join(dir, 'test_schema.rb'), %(schema :integer))
+
+        # Eager load schemas BEFORE setting default options
+        GlobalContext.instance.eager_load!
+
+        Schemacop.v3_default_options = { cast_str: true }.freeze
+
+        schema = GlobalContext.instance.schema_for('test_schema')
+        result = schema.validate('42')
+
+        # NOTE: Setting v3_default_options AFTER eager loading does not work
+        # because schemas are already cached. In Rails applications, the
+        # Railtie explicitly loads 'config/schemacop.rb' before eager loading,
+        # ensuring options are set before schemas are loaded.
+        #
+        # This test verifies that the options don't retroactively apply.
+        refute result.valid?, 'Options set after eager_load! should not affect already-loaded schemas'
+        assert_equal({ [] => ['Invalid type, got type "String", expected "integer".'] }, result.errors)
+      ensure
+        Schemacop.v3_default_options = {}
+      end
     end
   end
 end

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

@@ -32,7 +32,7 @@ module Schemacop
         end
 
         assert_validation('{42]') do
-          error '/', /JSON parse error: "(\d+: )?unexpected token at '{42]'"\./
+          error '/', /JSON parse error: "((\d+: )?unexpected token at '{42]'|expected object key, got '42]' at line \d+ column \d+)"\./
         end
 
         assert_validation('"foo"') do

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

@@ -193,6 +193,75 @@ module Schemacop
         end
       end
 
+      def test_max_precision
+        schema :number, max_precision: 2
+
+        assert_json(
+          type:         :number,
+          maxPrecision: 2
+        )
+
+        # Valid cases
+        assert_validation(42)          # Integer
+        assert_validation(3.14)        # 2 decimal places
+        assert_validation(3.1)         # 1 decimal place
+        assert_validation(3.0)         # 0 decimal places
+        assert_validation(0.12)        # 2 decimal places
+        assert_validation(1r)          # Rational should not be affected
+
+        # BigDecimal valid cases
+        assert_validation(BigDecimal('3.14'))     # 2 decimal places
+        assert_validation(BigDecimal('3.1'))      # 1 decimal place
+        assert_validation(BigDecimal('3.0'))      # 0 decimal places (with trailing zero)
+        assert_validation(BigDecimal('3'))        # 0 decimal places
+        assert_validation(BigDecimal('3.00'))     # trailing zeros should be ignored
+
+        # Invalid cases - Float
+        assert_validation(3.141) do
+          error '/', 'Value must have a maximum precision of 2 digits after the decimal point.'
+        end
+
+        assert_validation(0.123) do
+          error '/', 'Value must have a maximum precision of 2 digits after the decimal point.'
+        end
+
+        assert_validation(123.456789) do
+          error '/', 'Value must have a maximum precision of 2 digits after the decimal point.'
+        end
+
+        # Invalid cases - BigDecimal
+        assert_validation(BigDecimal('3.141')) do
+          error '/', 'Value must have a maximum precision of 2 digits after the decimal point.'
+        end
+
+        assert_validation(BigDecimal('0.123')) do
+          error '/', 'Value must have a maximum precision of 2 digits after the decimal point.'
+        end
+
+        # Test with max_precision: 0
+        schema :number, max_precision: 0
+
+        assert_json(
+          type:         :number,
+          maxPrecision: 0
+        )
+
+        assert_validation(42)
+        assert_validation(3.0)
+        assert_validation(0)
+        assert_validation(BigDecimal('3'))
+        assert_validation(BigDecimal('3.0'))
+        assert_validation(BigDecimal('3.00'))
+
+        assert_validation(3.1) do
+          error '/', 'Value must have a maximum precision of 0 digits after the decimal point.'
+        end
+
+        assert_validation(BigDecimal('3.1')) do
+          error '/', 'Value must have a maximum precision of 0 digits after the decimal point.'
+        end
+      end
+
       # Helper function that checks for all the options if the option is
       # an allowed class or something else, in which case it needs to raise
       def validate_self_should_error(value_to_check)
@@ -239,6 +308,21 @@ module Schemacop
           schema :number, multiple_of: 0
         end
 
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "max_precision" must be a non-negative integer.' do
+          schema :number, max_precision: -1
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "max_precision" must be a non-negative integer.' do
+          schema :number, max_precision: 2.5
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "max_precision" must be a non-negative integer.' do
+          schema :number, max_precision: '2'
+        end
+
         validate_self_should_error(1 + 0i) # Complex
         validate_self_should_error(Object.new)
         validate_self_should_error(true)
@@ -310,6 +394,33 @@ module Schemacop
                     })
       end
 
+      def test_combined_validations_with_max_precision
+        schema :number, minimum: 0, maximum: 100, max_precision: 1
+
+        assert_json(
+          type:         :number,
+          minimum:      0,
+          maximum:      100,
+          maxPrecision: 1
+        )
+
+        assert_validation(50.5)
+        assert_validation(0.1)
+        assert_validation(100.0)
+
+        assert_validation(50.55) do
+          error '/', 'Value must have a maximum precision of 1 digits after the decimal point.'
+        end
+
+        assert_validation(-0.1) do
+          error '/', 'Value must have a minimum of 0.'
+        end
+
+        assert_validation(100.1) do
+          error '/', 'Value must have a maximum of 100.'
+        end
+      end
+
       def test_cast_str
         schema :number, cast_str: true, minimum: 0.0, maximum: 50r, multiple_of: BigDecimal('0.5')
 

metadata

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