lutaml-model 0.8.19 → 0.8.23

data/lib/compat/opal/moxml_boot.rb

@@ -34,6 +34,10 @@ if RUBY_ENGINE == "opal"
   require "moxml/doctype"
   require "moxml/entity_reference"
   require "moxml/entity_registry"
+  require "moxml/entity"
+  require "moxml/entity/restorer"
+  require "moxml/entity/reference"
+  require "moxml/xml_emitter"
   require "moxml/adapter"
   require "moxml/adapter/base"
   require "moxml/adapter/customized_rexml"
@@ -46,10 +50,11 @@ if RUBY_ENGINE == "opal"
   require "moxml/sax/namespace_splitter"
   require "moxml/adapter/rexml"
   require "moxml/adapter/customized_oga"
+  require "moxml/adapter/customized_oga/entity_decoder"
+  require "moxml/adapter/customized_oga/raw_value_override"
   require "moxml/adapter/customized_oga/xml_declaration"
   require "moxml/adapter/customized_oga/xml_generator"
   require "moxml/adapter/oga"
-  require "moxml/document_builder"
   require "moxml/builder"
   require "moxml/context"
   require "moxml/config"

data/lib/lutaml/hash_format/format.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Internal Hash format implementation. Loaded from lib/lutaml/hash_format.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+module Lutaml
+  module HashFormat
+    class Error < StandardError; end
+
+    autoload :Adapter, "#{__dir__}/adapter"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :hash,
+  mapping_class: Lutaml::HashFormat::Adapter::Mapping,
+  adapter_class: Lutaml::HashFormat::Adapter::StandardAdapter,
+  transformer: Lutaml::HashFormat::Adapter::Transform,
+  key_value: true,
+  adapter_options: {
+    available: %i[standard standard_hash],
+    default: :standard,
+  },
+)
+
+require_relative "type/serializers"
+Lutaml::HashFormat::Type::Serializers.register_all!

data/lib/lutaml/hash_format.rb

@@ -1,29 +1,7 @@
 # frozen_string_literal: true
 
-# Hash format module
-# Provides Lutaml::HashFormat namespace for Hash serialization
-
-module Lutaml
-  module HashFormat
-    class Error < StandardError; end
-
-    autoload :Adapter, "#{__dir__}/hash_format/adapter"
-  end
-end
-
-# Register Hash format with the format registry
-Lutaml::Model::FormatRegistry.register(
-  :hash,
-  mapping_class: Lutaml::HashFormat::Adapter::Mapping,
-  adapter_class: Lutaml::HashFormat::Adapter::StandardAdapter,
-  transformer: Lutaml::HashFormat::Adapter::Transform,
-  key_value: true,
-  adapter_options: {
-    available: %i[standard standard_hash],
-    default: :standard,
-  },
-)
-
-# Register Hash type serializers
-require_relative "hash_format/type/serializers"
-Lutaml::HashFormat::Type::Serializers.register_all!
+# Public Hash format entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
+require_relative "model"
+require_relative "hash_format/format"

data/lib/lutaml/json/adapter/oj_adapter.rb

@@ -17,6 +17,13 @@ module Lutaml
         end
 
         # rubocop:disable Style/ArgumentsForwarding -- anonymous * requires Ruby 3.2+
+        # Oj has its own option namespace and its own escape_mode. Handing it
+        # the stdlib generator's options overrides that configuration, so it
+        # takes none of them -- which is what it received before.
+        def ignores_generator_options?
+          true
+        end
+
         def to_json(*args)
           require "oj"
           # Handle KeyValueElement input (new symmetric architecture)

data/lib/lutaml/json/adapter/standard_adapter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "../generator_options"
 
 module Lutaml
   module Json
@@ -9,12 +10,16 @@ module Lutaml
         FORMAT_SYMBOL = :json
 
         def self.parse(json, _options = {})
-          JSON.parse(json, create_additions: false)
+          JSON.parse(json)
         end
 
-        def to_json(*args)
-          options = args.first || {}
+        # This adapter hands its payload to the stdlib generator, so a
+        # JSON::State carrying the outer formatting is meaningful here.
+        def accepts_generator_state?
+          true
+        end
 
+        def to_json(*args)
           # Handle KeyValueElement input (new symmetric architecture)
           attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
                                       # Unwrap __root__ wrapper to get actual content
@@ -24,10 +29,17 @@ module Lutaml
                                       @attributes
                                     end
 
+          unless GeneratorOptions.lutaml_options?(args.first)
+            return JSON.generate(attributes_to_serialize, args.first)
+          end
+
+          options = args.first || {}
+          generator_options = GeneratorOptions.filter(options)
+
           if options[:pretty]
-            JSON.pretty_generate(attributes_to_serialize, *args)
+            JSON.pretty_generate(attributes_to_serialize, generator_options)
           else
-            JSON.generate(attributes_to_serialize, *args)
+            JSON.generate(attributes_to_serialize, generator_options)
           end
         end
       end

data/lib/lutaml/json/format.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Internal JSON format implementation. Loaded from lib/lutaml/json.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+require "lutaml/model/runtime_compatibility"
+require_relative "../key_value/format"
+
+module Lutaml
+  module Json
+    class Error < StandardError; end
+
+    require_relative "adapter/document"
+    require_relative "adapter/mapping"
+    require_relative "adapter/mapping_rule"
+    require_relative "adapter/transform"
+    require_relative "adapter/standard_adapter"
+    Lutaml::Model::RuntimeCompatibility.require_native(
+      "#{__dir__}/adapter/oj_adapter",
+      "#{__dir__}/adapter/multi_json_adapter",
+    )
+    require_relative "schema"
+
+    # Convenience aliases for common classes at the module level
+    # Allows Lutaml::Json::Mapping to resolve to Lutaml::Json::Adapter::Mapping
+    def self.const_missing(name)
+      if Adapter.const_defined?(name, false)
+        Adapter.const_get(name, false)
+      else
+        super
+      end
+    end
+
+    # Detect available JSON adapters
+    def self.detect_adapter
+      return :standard if defined?(::JSON) && Lutaml::Model.opal?
+      return :oj if defined?(::Oj)
+      return :multi_json if defined?(::MultiJson)
+      return :standard if defined?(::JSON)
+
+      nil
+    end
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :json,
+  mapping_class: Lutaml::Json::Adapter::Mapping,
+  adapter_class: Lutaml::Json::Adapter::StandardAdapter,
+  transformer: Lutaml::Json::Adapter::Transform,
+  key_value: true,
+  adapter_options: {
+    available: %i[standard standard_json multi_json oj],
+    default: :standard,
+  },
+)
+
+require_relative "type/serializers"
+Lutaml::Json::Type::Serializers.register_all!

data/lib/lutaml/json/generator_options.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lutaml
+  module Json
+    # Filters the options LutaML threads through serialization down to the
+    # subset the JSON generator accepts.
+    #
+    # json 2.x silently ignored unknown generator options; json 3.0 raises
+    # ArgumentError on them, so LutaML's own options (:register, :pretty and
+    # any caller-supplied extras) have to be stripped before they reach
+    # JSON.generate.
+    module GeneratorOptions
+      # Options the generator accepts on both json 2.x and 3.x. Measured
+      # against 2.9.1, 2.15.2, 2.19.9, 2.20.0, 2.21.1, 2.21.2 and 3.0.0.
+      # :escape_slash is NOT here because json 3.0 removed it; on 2.x it still
+      # arrives via DERIVED_PERMITTED. :allow_duplicate_key IS here because the
+      # generator accepts it on every version while JSON::State never exposed
+      # it as an accessor, so the derived half alone would miss it.
+      BASE_PERMITTED = %i[
+        allow_duplicate_key allow_nan array_nl as_json ascii_only
+        buffer_initial_length depth indent max_nesting object_nl script_safe
+        sort_keys space space_before strict
+      ].freeze
+
+      # Additive, so a json release that adds an option needs no change here.
+      # Opal's JSON shim has no State class, hence the guard.
+      DERIVED_PERMITTED =
+        if defined?(::JSON::State)
+          accessors = ::JSON::State.instance_methods(false).grep(/\A[a-z_][a-z0-9_]*=\z/)
+          accessors.map { |name| name.to_s.chomp("=").to_sym }
+        else
+          []
+        end.freeze
+
+      PERMITTED = (BASE_PERMITTED | DERIVED_PERMITTED).freeze
+
+      # json 3.0 removed :escape_slash, which was only ever an alias of
+      # :script_safe. Dropping it would silently stop escaping slashes, so it
+      # is translated instead of discarded.
+      RENAMED = { escape_slash: :script_safe }.freeze
+
+      def self.filter(options)
+        return {} unless options.is_a?(::Hash)
+
+        options.each_with_object({}) do |(key, value), kept|
+          key = RENAMED.fetch(key, key) unless PERMITTED.include?(key)
+          kept[key] = value if PERMITTED.include?(key)
+        end
+      end
+
+      # Ruby's JSON generator calls #to_json with a JSON::State whenever a
+      # document is nested inside another JSON.generate call. That is the
+      # generator's own state, not a LutaML options hash, and json 3.0 removed
+      # JSON::State#[], so it must never be read like one.
+      def self.lutaml_options?(argument)
+        argument.nil? || argument.is_a?(::Hash)
+      end
+    end
+  end
+end

data/lib/lutaml/json.rb

@@ -1,62 +1,7 @@
 # frozen_string_literal: true
 
-# JSON format module
-# Provides Lutaml::Json namespace for JSON serialization
-
-require "lutaml/model/runtime_compatibility"
+# Public JSON format entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
 require_relative "model"
-require_relative "key_value"
-
-module Lutaml
-  module Json
-    class Error < StandardError; end
-
-    require_relative "json/adapter/document"
-    require_relative "json/adapter/mapping"
-    require_relative "json/adapter/mapping_rule"
-    require_relative "json/adapter/transform"
-    require_relative "json/adapter/standard_adapter"
-    Lutaml::Model::RuntimeCompatibility.require_native(
-      "#{__dir__}/json/adapter/oj_adapter",
-      "#{__dir__}/json/adapter/multi_json_adapter",
-    )
-    require_relative "json/schema"
-
-    # Convenience aliases for common classes at the module level
-    # Allows Lutaml::Json::Mapping to resolve to Lutaml::Json::Adapter::Mapping
-    def self.const_missing(name)
-      if Adapter.const_defined?(name, false)
-        Adapter.const_get(name, false)
-      else
-        super
-      end
-    end
-
-    # Detect available JSON adapters
-    def self.detect_adapter
-      return :standard if defined?(::JSON) && Lutaml::Model.opal?
-      return :oj if defined?(::Oj)
-      return :multi_json if defined?(::MultiJson)
-      return :standard if defined?(::JSON)
-
-      nil
-    end
-  end
-end
-
-# Register JSON format with the format registry
-Lutaml::Model::FormatRegistry.register(
-  :json,
-  mapping_class: Lutaml::Json::Adapter::Mapping,
-  adapter_class: Lutaml::Json::Adapter::StandardAdapter,
-  transformer: Lutaml::Json::Adapter::Transform,
-  key_value: true,
-  adapter_options: {
-    available: %i[standard standard_json multi_json oj],
-    default: :standard,
-  },
-)
-
-# Register JSON type serializers
-require_relative "json/type/serializers"
-Lutaml::Json::Type::Serializers.register_all!
+require_relative "json/format"

data/lib/lutaml/jsonl/adapter/standard_adapter.rb

@@ -14,7 +14,7 @@ module Lutaml
             next if line.strip.empty?
 
             begin
-              results << JSON.parse(line, create_additions: false)
+              results << JSON.parse(line)
             rescue JSON::ParserError => e
               warn "Skipping invalid line: #{e.message}"
             end

data/lib/lutaml/jsonl/format.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Internal JSONL format implementation. Loaded from lib/lutaml/jsonl.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+module Lutaml
+  module Jsonl
+    class Error < StandardError; end
+
+    autoload :Adapter, "#{__dir__}/adapter"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :jsonl,
+  mapping_class: Lutaml::Jsonl::Adapter::Mapping,
+  adapter_class: Lutaml::Jsonl::Adapter::StandardAdapter,
+  transformer: Lutaml::Jsonl::Adapter::Transform,
+  key_value: true,
+)

data/lib/lutaml/jsonl.rb

@@ -1,21 +1,7 @@
 # frozen_string_literal: true
 
-# JSONL format module
-# Provides Lutaml::Jsonl namespace for JSONL serialization
-
-module Lutaml
-  module Jsonl
-    class Error < StandardError; end
-
-    autoload :Adapter, "#{__dir__}/jsonl/adapter"
-  end
-end
-
-# Register JSONL format with the format registry
-Lutaml::Model::FormatRegistry.register(
-  :jsonl,
-  mapping_class: Lutaml::Jsonl::Adapter::Mapping,
-  adapter_class: Lutaml::Jsonl::Adapter::StandardAdapter,
-  transformer: Lutaml::Jsonl::Adapter::Transform,
-  key_value: true,
-)
+# Public JSONL format entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
+require_relative "model"
+require_relative "jsonl/format"

data/lib/lutaml/jsonld/adapter.rb

@@ -1,21 +1,29 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "../json/generator_options"
 
 module Lutaml
   module JsonLd
     class Adapter < Lutaml::KeyValue::Document
       def self.parse(jsonld_string, _options = {})
-        JSON.parse(jsonld_string, create_additions: false)
+        JSON.parse(jsonld_string)
       end
 
       def to_jsonld(*args)
-        options = args.first || {}
         data = @attributes
+
+        unless Lutaml::Json::GeneratorOptions.lutaml_options?(args.first)
+          return JSON.generate(data, args.first)
+        end
+
+        options = args.first || {}
+        generator_options = Lutaml::Json::GeneratorOptions.filter(options)
+
         if options[:pretty]
-          JSON.pretty_generate(data, *args)
+          JSON.pretty_generate(data, generator_options)
         else
-          JSON.generate(data, *args)
+          JSON.generate(data, generator_options)
         end
       end
     end

data/lib/lutaml/key_value/adapter/json/oj_adapter.rb

@@ -21,6 +21,13 @@ module Lutaml
           end
 
           # rubocop:disable Style/ArgumentsForwarding -- anonymous * requires Ruby 3.2+
+          # Oj has its own option namespace and its own escape_mode. Handing it
+          # the stdlib generator's options overrides that configuration, so it
+          # takes none of them -- which is what it received before.
+          def ignores_generator_options?
+            true
+          end
+
           def to_json(*args)
             require "oj"
             # Handle KeyValueElement input (new symmetric architecture)

data/lib/lutaml/key_value/adapter/json/standard_adapter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "../../../json/generator_options"
 
 # Backward compatibility - delegates to Lutaml::Json::Adapter
 # @deprecated Use Lutaml::Json::Adapter::StandardAdapter instead
@@ -13,12 +14,16 @@ module Lutaml
           FORMAT_SYMBOL = :json
 
           def self.parse(json, _options = {})
-            JSON.parse(json, create_additions: false)
+            JSON.parse(json)
           end
 
-          def to_json(*args)
-            options = args.first || {}
+          # This adapter hands its payload to the stdlib generator, so a
+          # JSON::State carrying the outer formatting is meaningful here.
+          def accepts_generator_state?
+            true
+          end
 
+          def to_json(*args)
             # Handle KeyValueElement input (new symmetric architecture)
             attributes_to_serialize = if @attributes.is_a?(Lutaml::KeyValue::DataModel::Element)
                                         # Unwrap __root__ wrapper to get actual content
@@ -28,10 +33,17 @@ module Lutaml
                                         @attributes
                                       end
 
+            unless Lutaml::Json::GeneratorOptions.lutaml_options?(args.first)
+              return JSON.generate(attributes_to_serialize, args.first)
+            end
+
+            options = args.first || {}
+            generator_options = Lutaml::Json::GeneratorOptions.filter(options)
+
             if options[:pretty]
-              JSON.pretty_generate(attributes_to_serialize, *args)
+              JSON.pretty_generate(attributes_to_serialize, generator_options)
             else
-              JSON.generate(attributes_to_serialize, *args)
+              JSON.generate(attributes_to_serialize, generator_options)
             end
           end
         end

data/lib/lutaml/key_value/adapter/jsonl/standard_adapter.rb

@@ -15,7 +15,7 @@ module Lutaml
               next if line.strip.empty?
 
               begin
-                results << JSON.parse(line, create_additions: false)
+                results << JSON.parse(line)
               rescue JSON::ParserError => e
                 warn "Skipping invalid line: #{e.message}"
               end

data/lib/lutaml/key_value/format.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Internal KeyValue implementation. Loaded from lib/lutaml/key_value.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+module Lutaml
+  module KeyValue
+    autoload :DataModel, "#{__dir__}/data_model"
+    autoload :Document, "#{__dir__}/document"
+    autoload :Mapping, "#{__dir__}/mapping"
+    autoload :MappingRule, "#{__dir__}/mapping_rule"
+    autoload :Transform, "#{__dir__}/transform"
+    autoload :Transformation, "#{__dir__}/transformation"
+    autoload :TransformationBuilder, "#{__dir__}/transformation_builder"
+    autoload :Adapter, "#{__dir__}/adapter"
+  end
+end
+
+# Register KeyValue transformation builders for all key-value formats
+%i[json yaml toml hash].each do |format|
+  Lutaml::Model::TransformationRegistry.register_builder(
+    format, Lutaml::KeyValue::TransformationBuilder
+  )
+end

data/lib/lutaml/key_value/transform.rb

@@ -249,7 +249,10 @@ format)
         value = apply_value_map(value, rule.value_map(:from, options), attr)
 
         if rule.has_custom_method_for_deserialization?
-          return unless Lutaml::Model::Utils.present?(value)
+          # An empty value ("", [], {}) is a present value per the
+          # missing-values semantics and must reach the custom method;
+          # only nil (non-existent) skips it (lutaml-model#746).
+          return if value.nil?
 
           return rule.deserialize(instance, value, attributes, model_class)
         end

data/lib/lutaml/key_value/transformation/value_serializer.rb

@@ -88,11 +88,9 @@ model_class: nil)
         # @param rule [CompiledRule] The compiled rule
         # @return [Boolean] true if the rule defines a nested model
         def nested_model?(rule)
-          # rubocop:disable Style/IncludeOrExtend
           # Use include? instead of < because < returns nil (not false) for non-subclasses
           rule.attribute_type.is_a?(Class) &&
             rule.attribute_type.include?(Lutaml::Model::Serialize)
-          # rubocop:enable Style/IncludeOrExtend
         end
 
         # Serialize a nested model to a hash representation.

data/lib/lutaml/key_value.rb

@@ -1,24 +1,7 @@
 # frozen_string_literal: true
 
-module Lutaml
-  module KeyValue
-    autoload :DataModel, "#{__dir__}/key_value/data_model"
-    autoload :Document, "#{__dir__}/key_value/document"
-    autoload :Mapping, "#{__dir__}/key_value/mapping"
-    autoload :MappingRule, "#{__dir__}/key_value/mapping_rule"
-    autoload :Transform, "#{__dir__}/key_value/transform"
-    autoload :Transformation, "#{__dir__}/key_value/transformation"
-    autoload :TransformationBuilder,
-             "#{__dir__}/key_value/transformation_builder"
-    autoload :Adapter, "#{__dir__}/key_value/adapter"
-  end
-end
-
+# Public KeyValue entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
 require_relative "model"
-
-# Register KeyValue transformation builders for all key-value formats
-%i[json yaml toml hash].each do |format|
-  Lutaml::Model::TransformationRegistry.register_builder(
-    format, Lutaml::KeyValue::TransformationBuilder
-  )
-end
+require_relative "key_value/format"