schemacop 3.0.35 → 3.0.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80f588e0e3422fa0fea90f6725f48cb7eab64b7b2d6158e93e05496bc51f7565
-  data.tar.gz: 18b0514093843e7b1065e3b2c102263cbb4afa708cf8fa13f7c404cbec037abe
+  metadata.gz: 56a24074bd3792c20ee7e2f0bb1a8c3f4aa6d411a9a4c8010c9a52f0e828e6a3
+  data.tar.gz: ca4a752be493fe721122a77c5fb6844098c968dddf860fdcb0e33ef9a98880c3
 SHA512:
-  metadata.gz: f54e94a656fa9df82c4adde9f81d60a5f93b673018a8f9d50a80c755aa2b67ec362eeace426a1b4fcd9cbd4a0af8100b845b876afc37a2de5dac82a8b14acd6f
-  data.tar.gz: 8e362b61caf5ba6f885cef3014e53677e3d76775f31945fc70b0a7400cf465d5c28a0a6c053288e38a4642f8dd13b60cd35047dfe58a5fb8c88eecafc65c9499
+  metadata.gz: da3e3672206befe40e6487677c6c879192a3fdaf450e3621566be86dd1ccc9c487571a70cf7f1933294d5de9cd86094791e22cd659109a97baa432917138f296
+  data.tar.gz: 69d79cf5ad0702b80f930a9227f9279c2f758b3cb51965596145d82ec735b0fe8bb6648f219b6c1858d82f8a339ccdc388db71c3767573a074562a063eefcade

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Change log
 
+## 3.0.37 (2026-02-24)
+
+* Add inline ref support for hash nodes via `ref! nil, :SchemaName`. This
+  unpacks the referenced schema's properties directly into the parent hash
+  instead of nesting them under a key. Produces `allOf` with `$ref` in the
+  JSON/Swagger output.
+
+  Internal reference: `#146962`.
+
+## 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

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright © 2016 - 2024 Sitrox
+Copyright © 2016 - 2026 Sitrox
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -122,4 +122,4 @@ To run tests:
 
 ## Copyright
 
-Copyright © 2016 - 2025 Sitrox. See `LICENSE` for further details.
+Copyright © 2016 - 2026 Sitrox. See `LICENSE` for further details.

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.
 
@@ -507,7 +507,7 @@ 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.
@@ -636,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
 
@@ -704,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
@@ -759,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
@@ -850,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:
@@ -951,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
@@ -1078,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
@@ -1098,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
@@ -1158,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:
@@ -1494,6 +1494,131 @@ schema.validate!([{first_name: 'Joe', last_name: 'Doe'}]) # => [{"first_name"=>"
 schema.validate!([id: 42, first_name: 'Joe'])             # => Schemacop::Exceptions::ValidationError: /[0]/last_name: Value must be given. /[0]: Obsolete property "id".
 ```
 
+#### Inline References
+
+By passing `nil` as the name, you can "inline" a referenced schema into the
+parent hash. Instead of nesting the referenced properties under a key, they are
+unpacked directly into the parent:
+
+```ruby
+schema = Schemacop::Schema3.new :hash do
+  scm :BasicInfo do
+    int! :id
+    str! :name
+  end
+
+  ref! nil, :BasicInfo
+  str! :extra
+end
+
+# Properties from the referenced schema are validated at the top level
+schema.validate!({id: 1, name: 'John', extra: 'info'})
+# => {"id"=>1, "name"=>"John", "extra"=>"info"}
+
+# Required properties from the ref are enforced
+schema.validate!({extra: 'info'})
+# => Schemacop::Exceptions::ValidationError: /id: Value must be given. /name: Value must be given.
+
+# Unknown properties are still rejected
+schema.validate!({id: 1, name: 'John', extra: 'info', unknown: 'value'})
+# => Schemacop::Exceptions::ValidationError: /: Obsolete property "unknown".
+```
+
+Casting works as expected — values from the inline ref are cast according to the
+referenced schema's types:
+
+```ruby
+schema = Schemacop::Schema3.new :hash do
+  scm :BasicInfo do
+    str! :born_at, format: :date
+    str! :name
+  end
+
+  ref! nil, :BasicInfo
+  str! :extra
+end
+
+result = schema.validate!({born_at: '1990-01-13', name: 'John', extra: 'info'})
+result[:born_at] # => Date<"Sat, 13 Jan 1990">
+```
+
+You can also use multiple inline refs in the same hash:
+
+```ruby
+schema = Schemacop::Schema3.new :hash do
+  scm :BasicInfo do
+    int! :id
+    str! :name
+  end
+
+  scm :Timestamps do
+    str! :created_at, format: :date
+  end
+
+  ref! nil, :BasicInfo
+  ref! nil, :Timestamps
+  str! :extra
+end
+
+schema.validate!({id: 1, name: 'John', created_at: '2024-01-01', extra: 'info'})
+# => {"id"=>1, "name"=>"John", "created_at"=>Mon, 01 Jan 2024, "extra"=>"info"}
+```
+
+If a direct property has the same name as one from the inline ref, the direct
+property takes precedence:
+
+```ruby
+schema = Schemacop::Schema3.new :hash do
+  scm :BasicInfo do
+    str! :name
+  end
+
+  ref! nil, :BasicInfo
+  int! :name  # Direct property takes precedence
+end
+
+schema.validate!({name: 42})      # => {"name"=>42}
+schema.validate!({name: 'John'})
+# => Schemacop::Exceptions::ValidationError: /name: Invalid type, got type "String", expected "integer".
+```
+
+In the JSON / Swagger output, inline refs produce an `allOf` array containing
+the `$ref` entries alongside the hash's own properties:
+
+```ruby
+schema = Schemacop::Schema3.new :hash do
+  scm :BasicInfo do
+    int! :id
+    str! :name
+  end
+
+  ref! nil, :BasicInfo
+  str! :extra
+end
+
+schema.as_json
+# => {
+#   "allOf" => [
+#     { "$ref" => "#/definitions/BasicInfo" },
+#     {
+#       "type" => "object",
+#       "properties" => { "extra" => { "type" => "string" } },
+#       "additionalProperties" => false,
+#       "required" => ["extra"]
+#     }
+#   ],
+#   "definitions" => {
+#     "BasicInfo" => {
+#       "properties" => { "id" => { "type" => "integer" }, "name" => { "type" => "string" } },
+#       "additionalProperties" => false,
+#       "required" => ["id", "name"],
+#       "type" => "object"
+#     }
+#   },
+#   "type" => "object"
+# }
+```
+
 ## Context
 
 Schemacop also features the concept of a `Context`. You can define schemas in a
@@ -1559,7 +1684,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.
 
@@ -1582,7 +1707,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
@@ -1633,7 +1758,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:
@@ -1651,11 +1776,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.35
+3.0.37

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/hash_node.rb

@@ -12,6 +12,7 @@ module Schemacop
       supports_children(name: true)
 
       attr_reader :properties
+      attr_reader :inline_refs
 
       def self.allowed_options
         super + ATTRIBUTES - %i[dependencies] + %i[additional_properties ignore_obsolete_properties parse_json]
@@ -22,8 +23,13 @@ module Schemacop
       end
 
       def add_child(node)
-        unless node.name
-          fail Exceptions::InvalidSchemaError, 'Child nodes must have a name.'
+        if node.name.nil?
+          if node.is_a?(ReferenceNode)
+            @inline_refs << node
+            return
+          else
+            fail Exceptions::InvalidSchemaError, 'Child nodes must have a name.'
+          end
         end
 
         @properties[node.name] = node
@@ -54,6 +60,10 @@ module Schemacop
           end
         end
 
+        if @inline_refs.any?
+          return as_json_with_inline_refs(properties, pattern_properties)
+        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?
@@ -122,8 +132,29 @@ module Schemacop
           end
         end
 
+        # Validate inline ref properties #
+        inline_ref_property_names = Set.new
+
+        @inline_refs.each do |inline_ref|
+          target = inline_ref.target
+          next unless target
+
+          target.properties.each_value do |prop|
+            next if prop.name.is_a?(Regexp)
+            next if @properties.key?(prop.name)
+            next if inline_ref_property_names.include?(prop.name)
+
+            inline_ref_property_names << prop.name
+
+            result.in_path(prop.name) do
+              result.error "Key #{prop.name} must be given." if prop.require_key? && !data_hash.include?(prop.name)
+              prop._validate(data_hash[prop.name], result: result)
+            end
+          end
+        end
+
         # Validate additional properties #
-        specified_properties = @properties.keys.to_set
+        specified_properties = @properties.keys.to_set + inline_ref_property_names
         additional_properties = data_hash.reject { |k, _v| specified_properties.include?(k.to_s) }
 
         property_patterns = {}
@@ -173,7 +204,7 @@ module Schemacop
       end
 
       def children
-        @properties.values
+        @properties.values + @inline_refs
       end
 
       def cast(data)
@@ -208,8 +239,36 @@ module Schemacop
           end
         end
 
+        # Cast inline ref properties
+        inline_ref_property_names = Set.new
+
+        @inline_refs.each do |inline_ref|
+          target = inline_ref.target
+          next unless target
+
+          target.properties.each_value do |prop|
+            next if prop.name.is_a?(Regexp)
+            next if @properties.key?(prop.name)
+            next if inline_ref_property_names.include?(prop.name)
+
+            inline_ref_property_names << prop.name
+
+            prop_name = prop.as&.to_s || prop.name
+
+            casted_data = prop.cast(data_hash[prop.name])
+
+            if !casted_data.nil? || data_hash.include?(prop.name)
+              result[prop_name] = casted_data
+            end
+
+            if result[prop_name].nil? && !data_hash.include?(prop.name)
+              result.delete(prop_name)
+            end
+          end
+        end
+
         # Handle regex properties
-        specified_properties = @properties.keys.to_set
+        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) }
 
         if additional_properties.any? && property_patterns.any?
@@ -224,8 +283,8 @@ module Schemacop
         if options[:additional_properties].is_a?(TrueClass)
           result = data_hash.merge(result)
         elsif options[:additional_properties].is_a?(Node)
-          specified_properties = @properties.keys.to_set
-          additional_properties = data_hash.reject { |k, _v| specified_properties.include?(k.to_s.to_sym) }
+          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) }
           if additional_properties.any?
             additional_properties_result = {}
             additional_properties.each do |key, value|
@@ -240,8 +299,42 @@ 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
+
+        # 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?
+
+          if options[:additional_properties].is_a?(TrueClass)
+            own_schema[:additionalProperties] = true
+          elsif options[:additional_properties].is_a?(Node)
+            own_schema[:additionalProperties] = options[:additional_properties].as_json
+          else
+            own_schema[:additionalProperties] = false
+          end
+
+          required_properties = @properties.values.select(&:required?).map(&:name)
+          own_schema[:required] = required_properties if required_properties.any?
+
+          all_of << own_schema
+        end
+
+        json = { allOf: all_of }
+        return process_json(ATTRIBUTES, json)
+      end
+
       def init
         @properties = {}
+        @inline_refs = []
         @options[:type] = :object
         unless @options[:additional_properties].nil? || @options[:additional_properties].is_a?(TrueClass) || @options[:additional_properties].is_a?(FalseClass)
           fail Schemacop::Exceptions::InvalidSchemaError, 'Option "additional_properties" must be a boolean value'

data/schemacop.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: schemacop 3.0.35 ruby lib
+# stub: schemacop 3.0.37 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "schemacop".freeze
-  s.version = "3.0.35".freeze
+  s.version = "3.0.37".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-07-31"
+  s.date = "2026-02-24"
   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/reference_node_test.rb

@@ -362,6 +362,404 @@ module Schemacop
 
         assert_cast({ person: { born_at: '1990-01-13' } }, { person: { born_at: Date.new(1990, 1, 13) } }.with_indifferent_access)
       end
+
+      # --- Inline ref tests ---
+
+      def test_inline_ref_schema_builds_without_error
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+        end
+
+        assert_equal [], @schema.root.properties.keys
+        assert_equal 1, @schema.root.inline_refs.size
+      end
+
+      def test_inline_ref_validation
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+          str! :extra
+        end
+
+        assert_validation(id: 1, name: 'John', extra: 'info')
+      end
+
+      def test_inline_ref_validation_errors
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+          str! :extra
+        end
+
+        assert_validation(extra: 'info') do
+          error '/id', 'Value must be given.'
+          error '/name', 'Value must be given.'
+        end
+      end
+
+      def test_inline_ref_validation_type_errors
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+        end
+
+        assert_validation(id: 'not_an_int', name: 42) do
+          error '/id', 'Invalid type, got type "String", expected "integer".'
+          error '/name', 'Invalid type, got type "Integer", expected "string".'
+        end
+      end
+
+      def test_inline_ref_validation_obsolete_properties
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+        end
+
+        # Properties from inline ref are accepted
+        assert_validation(id: 1, name: 'John')
+
+        # Unknown properties are still rejected
+        assert_validation(id: 1, name: 'John', unknown: 'value') do
+          error '/', 'Obsolete property "unknown".'
+        end
+      end
+
+      def test_inline_ref_cast
+        schema do
+          scm :BasicInfo do
+            str! :born_at, format: :date
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+          str! :extra
+        end
+
+        assert_cast(
+          { born_at: '1990-01-13', name: 'John', extra: 'info' },
+          { born_at: Date.new(1990, 1, 13), name: 'John', extra: 'info' }.with_indifferent_access
+        )
+      end
+
+      def test_inline_ref_with_defaults
+        schema do
+          scm :BasicInfo do
+            str? :name, default: 'Anonymous'
+          end
+
+          ref! nil, :BasicInfo
+        end
+
+        assert_cast({}, { name: 'Anonymous' }.with_indifferent_access)
+      end
+
+      def test_inline_ref_with_optional_properties
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str? :nickname
+          end
+
+          ref! nil, :BasicInfo
+        end
+
+        assert_validation(id: 1)
+        assert_validation(id: 1, nickname: 'Johnny')
+      end
+
+      def test_inline_ref_as_json
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+          str! :extra
+        end
+
+        assert_json({
+                      definitions: {
+                        BasicInfo: {
+                          properties:           {
+                            id:   { type: :integer },
+                            name: { type: :string }
+                          },
+                          additionalProperties: false,
+                          required:             %w[id name],
+                          type:                 :object
+                        }
+                      },
+                      type:        :object,
+                      allOf:       [
+                        { '$ref' => '#/definitions/BasicInfo' },
+                        {
+                          type:                 :object,
+                          properties:           {
+                            extra: { type: :string }
+                          },
+                          additionalProperties: false,
+                          required:             %w[extra]
+                        }
+                      ]
+                    })
+      end
+
+      def test_inline_ref_as_json_no_own_properties
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+        end
+
+        assert_json({
+                      definitions: {
+                        BasicInfo: {
+                          properties:           {
+                            id:   { type: :integer },
+                            name: { type: :string }
+                          },
+                          additionalProperties: false,
+                          required:             %w[id name],
+                          type:                 :object
+                        }
+                      },
+                      type:        :object,
+                      allOf:       [
+                        { '$ref' => '#/definitions/BasicInfo' }
+                      ]
+                    })
+      end
+
+      def test_inline_ref_swagger_json
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+          str! :extra
+        end
+
+        assert_swagger_json({
+                              type:  :object,
+                              allOf: [
+                                { '$ref' => '#/components/schemas/BasicInfo' },
+                                {
+                                  type:                 :object,
+                                  properties:           {
+                                    extra: { type: :string }
+                                  },
+                                  additionalProperties: false,
+                                  required:             %w[extra]
+                                }
+                              ]
+                            })
+      end
+
+      def test_inline_ref_multiple
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          scm :Timestamps do
+            str! :created_at, format: :date
+          end
+
+          ref! nil, :BasicInfo
+          ref! nil, :Timestamps
+          str! :extra
+        end
+
+        # Validation
+        assert_validation(id: 1, name: 'John', created_at: '2024-01-01', extra: 'info')
+        assert_validation(extra: 'info') do
+          error '/id', 'Value must be given.'
+          error '/name', 'Value must be given.'
+          error '/created_at', 'Value must be given.'
+        end
+
+        # Casting
+        assert_cast(
+          { id: 1, name: 'John', created_at: '2024-01-01', extra: 'info' },
+          { id: 1, name: 'John', created_at: Date.new(2024, 1, 1), extra: 'info' }.with_indifferent_access
+        )
+
+        # JSON
+        assert_json({
+                      definitions: {
+                        BasicInfo:  {
+                          properties:           {
+                            id:   { type: :integer },
+                            name: { type: :string }
+                          },
+                          additionalProperties: false,
+                          required:             %w[id name],
+                          type:                 :object
+                        },
+                        Timestamps: {
+                          properties:           {
+                            created_at: { type: :string, format: :date }
+                          },
+                          additionalProperties: false,
+                          required:             %w[created_at],
+                          type:                 :object
+                        }
+                      },
+                      type:        :object,
+                      allOf:       [
+                        { '$ref' => '#/definitions/BasicInfo' },
+                        { '$ref' => '#/definitions/Timestamps' },
+                        {
+                          type:                 :object,
+                          properties:           {
+                            extra: { type: :string }
+                          },
+                          additionalProperties: false,
+                          required:             %w[extra]
+                        }
+                      ]
+                    })
+      end
+
+      def test_inline_ref_with_external_schema
+        context = Context.new
+
+        context.schema :BasicInfo do
+          int! :id
+          str! :name
+        end
+
+        with_context context do
+          schema do
+            ref! nil, :BasicInfo
+            str! :extra
+          end
+
+          assert_validation(id: 1, name: 'John', extra: 'info')
+          assert_validation(extra: 'info') do
+            error '/id', 'Value must be given.'
+            error '/name', 'Value must be given.'
+          end
+        end
+      end
+
+      def test_inline_ref_used_external_schemas
+        context = Context.new
+
+        context.schema :BasicInfo do
+          int! :id
+          str! :name
+        end
+
+        with_context context do
+          schema do
+            ref! nil, :BasicInfo
+            str! :extra
+          end
+
+          assert_equal %i[BasicInfo], @schema.root.used_external_schemas
+        end
+      end
+
+      def test_inline_ref_with_additional_properties_true
+        schema do
+          scm :BasicInfo do
+            int! :id
+            str! :name
+          end
+
+          ref! nil, :BasicInfo
+          str! :extra
+        end
+
+        # Without additional_properties: true, unknown props are rejected
+        assert_validation(id: 1, name: 'John', extra: 'info', unknown: 'value') do
+          error '/', 'Obsolete property "unknown".'
+        end
+      end
+
+      def test_inline_ref_property_name_collision
+        schema do
+          scm :BasicInfo do
+            str! :name
+            str? :description
+          end
+
+          ref! nil, :BasicInfo
+          int! :name # Direct property takes precedence
+        end
+
+        # Direct property (int!) takes precedence — string should fail
+        assert_validation(name: 42)
+        assert_validation(name: 'John') do
+          error '/name', 'Invalid type, got type "String", expected "integer".'
+        end
+
+        # Optional description from inline ref still works
+        assert_validation(name: 42, description: 'A description')
+      end
+
+      def test_inline_ref_collision_between_inline_refs
+        schema do
+          scm :BasicInfo do
+            str! :name
+            str? :description
+          end
+
+          scm :ExtraInfo do
+            int! :name # Clashes with BasicInfo's :name
+            str! :extra
+          end
+
+          ref! nil, :BasicInfo # First inline ref wins for :name
+          ref! nil, :ExtraInfo
+        end
+
+        # First inline ref wins: :name is validated as str! (from BasicInfo)
+        assert_validation(name: 'John', extra: 'info')
+        assert_validation(name: 42, extra: 'info') do
+          error '/name', 'Invalid type, got type "Integer", expected "string".'
+        end
+
+        # Properties unique to second inline ref still work
+        assert_validation(name: 'John') do
+          error '/extra', 'Value must be given.'
+        end
+
+        # Casting uses first inline ref's definition for :name
+        assert_cast(
+          { name: 'John', description: 'A desc', extra: 'info' },
+          { name: 'John', description: 'A desc', extra: 'info' }.with_indifferent_access
+        )
+      end
     end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: schemacop
 version: !ruby/object:Gem::Version
-  version: 3.0.35
+  version: 3.0.37
 platform: ruby
 authors:
 - Sitrox
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-31 00:00:00.000000000 Z
+date: 2026-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -38,8 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.4
-description:
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -151,7 +148,6 @@ homepage: https://github.com/sitrox/schemacop
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -166,8 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key:
+rubygems_version: 4.0.2
 specification_version: 4
 summary: Schemacop validates ruby structures consisting of nested hashes and arrays
   against simple schema definitions.