lutaml-xsd 1.1.13 → 1.2.0

data/docs/superpowers/specs/2026-10-20-moxml-leptris-migration-design.md

@@ -0,0 +1,169 @@
+# Design: complete Moxml migration, run on leptris, integrate `Moxml::XSD` engine validation
+
+- Date: 2026-10-20
+- Status: approved (design discussion 2026-10-18..20)
+- Scope: lutaml-xsd 1.1.x
+
+## 1. Context
+
+lutaml-xsd is ~95% on Moxml already: `validation/*`, `definition_extractor.rb`,
+and most of `spa/schema_serializer.rb` use `Moxml::Context`. Remaining gaps:
+
+- Direct Nokogiri usage survives in exactly one place:
+  `create_type_wrapper_xsd` and `resolve_type_prefix`
+  (`lib/lutaml/xsd/spa/schema_serializer.rb`), including
+  `require "nokogiri"`.
+- The bundle does not include the leptris adapter, so Moxml's default
+  adapter selection falls back to Nokogiri everywhere — including inside
+  lutaml-model 0.8.x, which is itself built on Moxml.
+- moxml 0.5.147 (pinned via lutaml-xsd#104) ships `Moxml::XSD`: an
+  adapter-agnostic XSD validation facade over engines that implement one
+  (leptris, nokogiri — "tier-1"). lutaml-xsd maintains a substantial
+  hand-rolled validation stack (5 rules, 14 facet validators, 10
+  base-type validators) that does not use it.
+
+## 2. Goals
+
+1. No direct Nokogiri usage in `lib/` — everything through Moxml.
+2. Dev/CI runs the stack on the Leptris engine via the `leptris` gem
+   (Gemfile-only; public dependency contract unchanged).
+3. Use `Moxml::XSD` where it helps: a full-document engine fast-path in
+   `Validation`, plus engine delegation for lexical and content-model
+   checks where supported, with the Ruby rule engine remaining
+   authoritative and the fallback everywhere else.
+4. CLAUDE.md documents the Moxml-only XML stack.
+
+## 3. Non-goals
+
+- No replacement of the Ruby rule engine by engine validation (tier-1
+  scope validates laxly outside named+typed top-level elements /
+  one-level content-model descent / lexical checks — silent
+  false-negatives are unacceptable).
+- No runtime adapter dependency in the gemspec (moxml itself declares
+  zero runtime deps; consumers bundle the adapters they want).
+- `XsdSpecValidator` (schema-level spec compliance) keeps its own rules;
+  `Moxml::XSD` validates instances, not schemas.
+- Removing the `xsdvi` dependency (it requires `nokogiri ~> 1.16`, so
+  nokogiri remains in the lockfile transitively; lutaml-xsd code simply
+  stops touching it).
+
+## 4. Dependency changes
+
+| Change | Where | Status |
+|---|---|---|
+| `moxml ~> 0.5.147` pin | gemspec | PR #104 (patch release 1.1.13 follows) |
+| `gem "leptris"` | Gemfile (dev) | this work |
+| drop `gem "nokogiri"` | Gemfile | this work (stays in lock via xsdvi) |
+
+Gemspec contract otherwise unchanged. moxml auto-selects leptris when
+the gem is present (`Leptris::XML::Document.create` probe); no adapter
+is hardcoded in lutaml-xsd.
+
+## 5. Workstream A — finish the Moxml port
+
+`spa/schema_serializer.rb`:
+
+- Delete `require "nokogiri"`.
+- `create_type_wrapper_xsd`: `Moxml::Context.new.parse(File.read(path))`;
+  `doc.at_xpath("//xs:schema", ns)` (Moxml `xpath`/`at_xpath` accept
+  namespace hashes exactly like Nokogiri);
+  `schema.namespace_definitions.find { |nd| nd.href == XSD_NS }`;
+  `doc.create_element("element")`; `element_node["name"] = ...`;
+  `element_node["type"] = type_ref`;
+  `element_node.namespace = xsd_ns_decl`; `schema.add_child(element_node)`;
+  `doc.to_xml` into the Tempfile.
+- `resolve_type_prefix`: same xpath + `namespace_definitions` mapping.
+- Spec: the generated wrapper XSD must match current Nokogiri output
+  (root `xs:schema`, wrapper `xs:element` in the XSD namespace, correct
+  prefix resolution). Regression-gate with a byte-equivalence test
+  captured before the port.
+
+## 6. Workstream B — leptris in the bundle
+
+- Add `gem "leptris"` to the Gemfile (dev/CI). Latest published:
+  1.9.372.0.
+- Verify `Moxml.new.config.adapter_name == :leptris` under the bundle;
+  CI stays adapter-neutral (moxml picks leptris when present, nokogiri
+  otherwise) so the suite runs both engines over time.
+
+## 7. Workstream C — `Moxml::XSD` engine integration
+
+### 7.1 New class `Lutaml::Xsd::Validation::EngineXsd`
+
+One instance per `ValidationJob`, built from the job's `Moxml::Context`:
+
+- `Moxml::XSD.supported?(context)` gates everything. Unsupported
+  adapters (Oga/Ox/REXML) yield an inert engine (`nil`-equivalent); job
+  behavior is unchanged.
+- Compiles each schema source in `repository.all_schemas` via
+  `context.xsd(source)`; schemas with non-nil `compile_error` are
+  skipped and surface as warnings — the Ruby rules still judge them.
+- `#validate(document)`: runs each compiled `Moxml::XSD::Schema#validate`,
+  maps findings, returns them merged.
+- Provenance: every mapped finding gets `code: "engine_validation"` so
+  consumers can tell engine findings from rule findings.
+
+### 7.2 Error mapping
+
+`Moxml::XSD::ValidationError(message:, line:, column:, path:)` →
+`Lutaml::Xsd::Validation::ValidationError` with
+`severity: :error` and `location:` derived from line/column/path.
+`to_s` keeps the `"<line>: <message>"` shape.
+
+### 7.3 Job wiring
+
+`ValidationJob#execute` gains a phase after `parse_xml`, gated by a new
+config feature `:engine_validation` (default: enabled when supported).
+Findings merge into the existing `ResultCollector`. A document is valid
+only when both engines are silent — engine findings are additive, the
+Ruby rule engine remains authoritative (laxness mitigation).
+
+### 7.4 Delegated checks
+
+An `EngineContext` (supported? flag + compiled schema handles) hangs off
+the job and reaches validators through the existing registries:
+
+- `validation/base_types/*`: when the engine is available,
+  `Moxml::XSD.builtin_valid?` / `schema.simple_valid?` run first; Ruby
+  logic stays the fallback (other adapters, engine gaps).
+- `validation/rules/content_model_validation_rule.rb` and
+  `occurrence_validation_rule.rb`: consult
+  `schema.content_valid?(element_name, children)` the same way.
+- No validator public interface changes; delegation is internal and
+  capability-gated (OCP: engine support is a registry concern, not a
+  per-validator branch sprawl).
+
+## 8. Testing
+
+Real objects throughout (no doubles, per standing rules):
+
+- Supported-engine shared context: engine tests run where leptris is
+  installed, skip cleanly elsewhere (`Moxml::XSD.supported?` probe).
+- Fallback specs: adapter forced to REXML; behavior byte-identical to
+  today (engine inert, no new findings, registries use Ruby paths).
+- Port specs: wrapper-XSD byte-equivalence vs. the captured Nokogiri
+  baseline.
+- Mapping specs: each `Moxml::XSD::ValidationError` field lands in the
+  right `Validation::ValidationError` field; merge semantics with Ruby
+  findings; `compile_error` → warning path.
+- Delegation specs: engine path and Ruby path agree on valid/invalid
+  fixtures from `spec/fixtures`; disagreement is a test failure.
+
+## 9. Risks
+
+- Tier-1 laxness → engine findings additive only; Ruby engine
+  authoritative; documented in CLAUDE.md and YARD.
+- Multi-schema repositories (imports, RNG→XSD-converted files) may
+  under-report in the engine → acceptable because findings are additive;
+  cross-schema resolution stays the Ruby engine's job.
+- Moxml serialization nuances in the wrapper-XSD port → byte-equivalence
+  spec catches drift.
+- leptris platform coverage → Gemfile-only today; runtime adoption is a
+  separate, owner-decided decision.
+
+## 10. Rollout order
+
+1. PR #104 merged + 1.1.13 patch release (moxml pin only).
+2. Workstreams A + B (port + leptris in Gemfile) — one PR.
+3. Workstream C (engine integration) — one PR.
+4. CLAUDE.md update lands with (2)/(3).

data/docs/superpowers/specs/2026-10-21-rule-engine-wiring-design.md

@@ -0,0 +1,84 @@
+# Design: wire the Ruby rule engine into production validation
+
+- Date: 2026-10-21
+- Status: implemented with this PR
+- Scope: lutaml-xsd 1.1.x
+
+## 1. Problem
+
+`Validator#build_rule_registry` returns an **empty** registry, and
+`RuleEngine#execute_rule` calls `rule.validate(document, repository,
+collector)` while every concrete rule implements
+`validate(instance_element, schema_definition, collector)`. Consequence:
+the production validation stack runs zero rules. The conformance harness
+(2026-10-20 baseline) measured pipeline mode == engine mode for exactly
+this reason; every deferred rule-depth gap is blocked on this wiring.
+
+## 2. Contract
+
+Rules stay element-scoped. The engine walks the instance document
+(depth-first over `XmlDocument#root_element` / `XmlElement#children`),
+resolves each element's schema declaration, and dispatches:
+
+```ruby
+rule.validate(instance_element, rule.schema_argument(schema_def, repository:),
+              collector, repository: repository)
+```
+
+- `ValidationRule#schema_argument(schema_def, repository:)` defaults to the
+  resolved schema element; rules override it when they validate against
+  something else (OccurrenceValidationRule returns the content-model
+  particle of the schema element's type).
+- `ValidationRule#runs_without_schema?` defaults false; the structure rule
+  returns true so undeclared elements still produce findings (its
+  element-existence check takes a nil declaration).
+- `repository:` is the resolver (not the raw repository), giving rules
+  named-type lookup (`resolve_type`) for `type="tns:…"` references.
+- Dispatch order follows the existing categories:
+  structure → type → constraint → facet → identity. Each rule invocation
+  keeps `RuleEngine`'s existing per-rule rescue.
+
+## 3. Schema definition resolution
+
+`Validation::SchemaDefinitionResolver` indexes, per repository instance:
+
+- top-level element declarations (`schema.element`)
+- inline element declarations, recursively through complex types'
+  sequence/choice/all particles and nested complex content
+
+Matching: local name equality, plus namespace compatibility — a schema
+with a target namespace matches only that namespace; a no-namespace schema
+matches a no-namespace instance element. Top-level declarations win over
+inline ones. `resolve_type(element)` finds a named complex/simple type for
+`element.type` references across the repository's schemas.
+
+Known limits (documented, deliberately deferred): dynamic typing
+(`xsi:type`) and derivation closure are not resolved; UPA/identity
+constraints remain rule-engine backlog items.
+
+## 4. Registry population
+
+`Validator#build_rule_registry` registers the five rules, gated by the
+existing feature flags:
+
+| rule | category | gate |
+|---|---|---|
+| ElementStructureRule | structure | always |
+| ContentModelValidationRule | structure | `validate_content_models` |
+| TypeValidationRule | type | `validate_types` |
+| AttributeValidationRule | constraint | `validate_attributes` |
+| OccurrenceValidationRule | constraint | `validate_occurrences` |
+
+## 5. Testing
+
+- Resolver specs with a real parsed schema and a minimal repository
+  stand-in (top-level, inline, namespaced, unknown, type references).
+- Engine integration: a `ValidationJob` with `engine_validation: false`
+  and an invalid instance must now produce rule findings (previously an
+  empty result). Valid instances stay clean.
+- Conformance harness re-run; pipeline-mode pass-rate recorded.
+
+## 6. Non-goals
+
+- No new validation rules; this PR only makes the existing rules execute.
+- No change to the engine fast-path or finding provenance.

data/lib/lutaml/xsd/conformance/runner.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "moxml"
+
+module Lutaml
+  module Xsd
+    module Conformance
+      # Runs the conformance corpus: one directory per case under
+      # spec/conformance/cases/, each holding schema.xsd plus
+      # valid-*.xml / invalid-*.xml instances.
+      #
+      # Two modes are measured independently:
+      # - :engine   — Moxml::XSD tier-1 validation (when the adapter
+      #               ships an engine)
+      # - :pipeline — the production Validator stack (ValidationJob with
+      #               the default rule registry)
+      #
+      # The report is a pass-rate per mode; conformance is a number.
+      class Runner
+        MODES = %i[engine pipeline].freeze
+
+        Case = Struct.new(:name, :schema_path, :valid, :invalid,
+                          keyword_init: true)
+        Result = Struct.new(:case_name, :mode, :passed, :total, :failures,
+                            :unsupported, keyword_init: true) do
+          def pass_rate
+            total.zero? ? 0.0 : passed.to_f / total
+          end
+        end
+
+        # Minimal repository shape the validation stack consumes.
+        class Repository
+          def initialize(schemas)
+            @schemas = schemas
+          end
+
+          attr_reader :schemas
+
+          def all_schemas
+            @schemas
+          end
+        end
+
+        def initialize(cases_dir)
+          @cases_dir = cases_dir
+        end
+
+        def cases
+          Dir.glob(File.join(@cases_dir, "*")).filter_map do |dir|
+            next unless File.directory?(dir)
+
+            schema = File.join(dir, "schema.xsd")
+            next unless File.exist?(schema)
+
+            Case.new(
+              name: File.basename(dir),
+              schema_path: schema,
+              valid: Dir.glob(File.join(dir, "valid-*.xml")),
+              invalid: Dir.glob(File.join(dir, "invalid-*.xml")),
+            )
+          end
+        end
+
+        # @return [Array<Result>]
+        def run
+          cases.flat_map do |kase|
+            MODES.map { |mode| run_case(kase, mode) }
+          end
+        end
+
+        # @return [String] human-readable report
+        def report(results)
+          lines = ["Conformance report", "=" * 60]
+          results.group_by(&:mode).each do |mode, mode_results|
+            supported = mode_results.reject(&:unsupported)
+            passed = supported.sum(&:passed)
+            total = supported.sum(&:total)
+            rate = total.zero? ? 0.0 : (passed.to_f / total * 100).round(1)
+            lines << format("%-10s %3d/%-3d checks (%5.1f%%)%s",
+                            mode, passed, total, rate,
+                            skipped_note(mode_results))
+            mode_results.each do |r|
+              next if r.unsupported
+
+              marker = r.failures.empty? ? "ok  " : "FAIL"
+              lines << format("  %s %-26s %d/%d",
+                              marker, r.case_name, r.passed, r.total)
+              r.failures.each { |f| lines << "         - #{f}" }
+            end
+          end
+          lines.join("\n")
+        end
+
+        private
+
+        def skipped_note(results)
+          skipped = results.count(&:unsupported)
+          skipped.zero? ? "" : " (#{skipped} cases unsupported)"
+        end
+
+        def run_case(kase, mode)
+          checks = kase.valid.map { |path| [path, true] } +
+            kase.invalid.map { |path| [path, false] }
+
+          results = checks.map do |path, expected|
+            actual = validate(kase, path, mode)
+            [path, expected, actual]
+          end
+
+          unsupported = results.any? { |_, _, actual| actual == :unsupported }
+          failures = results.reject do |_path, expected, actual|
+            actual == :unsupported || expected == actual
+          end.map { |path, expected, _| "#{File.basename(path)} (expected #{expected ? 'valid' : 'invalid'})" }
+
+          Result.new(
+            case_name: kase.name,
+            mode: mode,
+            passed: unsupported ? 0 : results.count { |_, expected, actual| expected == actual },
+            total: unsupported ? 0 : results.length,
+            failures: failures,
+            unsupported: unsupported,
+          )
+        end
+
+        def validate(kase, instance_path, mode)
+          case mode
+          when :engine then engine_valid?(kase, instance_path)
+          when :pipeline then pipeline_valid?(kase, instance_path)
+          end
+        end
+
+        def engine_valid?(kase, instance_path)
+          engine = engine_for(kase)
+          return :unsupported unless engine&.supported?
+
+          engine.findings_for(File.read(instance_path)).empty?
+        end
+
+        def pipeline_valid?(kase, instance_path)
+          config = Validation::ValidationConfiguration.new
+          job = Validation::ValidationJob.new(
+            xml_content: File.read(instance_path),
+            repository: repository_for(kase),
+            rule_registry: Validation::RuleRegistry.default(config),
+            config: config,
+          )
+          job.execute.valid?
+        end
+
+        def engine_for(kase)
+          @engine_cache ||= {}
+          @engine_cache[kase.name] ||= Validation::EngineContext.compile(
+            repository_for(kase),
+          )
+        end
+
+        def repository_for(kase)
+          @repository_cache ||= {}
+          @repository_cache[kase.name] ||= begin
+            schema = Lutaml::Xml::Schema::Xsd.parse(
+              File.read(kase.schema_path), location: kase.schema_path
+            )
+            Repository.new(schema.target_namespace.to_s => schema)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/json_schema_exporter.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lutaml
+  module Xsd
+    # Exports an XSD schema to a JSON Schema 2020-12 document.
+    #
+    # The mapping covers the common core and deliberately records its
+    # losses: XSD regular expressions are not ECMA-262 patterns, identity
+    # constraints and substitution groups have no direct JSON Schema
+    # equivalent, and derivation is flattened. See docs/JSON_SCHEMA.adoc.
+    class JsonSchemaExporter
+      DRAFT = "https://json-schema.org/draft/2020-12/schema"
+
+      BUILTIN_TYPES = {
+        "string" => { "type" => "string" },
+        "normalizedString" => { "type" => "string" },
+        "token" => { "type" => "string" },
+        "boolean" => { "type" => "boolean" },
+        "decimal" => { "type" => "number" },
+        "float" => { "type" => "number" },
+        "double" => { "type" => "number" },
+        "integer" => { "type" => "integer" },
+        "positiveInteger" => { "type" => "integer", "minimum" => 1 },
+        "negativeInteger" => { "type" => "integer", "maximum" => -1 },
+        "nonPositiveInteger" => { "type" => "integer", "maximum" => 0 },
+        "nonNegativeInteger" => { "type" => "integer", "minimum" => 0 },
+        "long" => { "type" => "integer" },
+        "int" => { "type" => "integer" },
+        "short" => { "type" => "integer" },
+        "byte" => { "type" => "integer" },
+        "unsignedLong" => { "type" => "integer", "minimum" => 0 },
+        "unsignedInt" => { "type" => "integer", "minimum" => 0 },
+        "unsignedShort" => { "type" => "integer", "minimum" => 0 },
+        "unsignedByte" => { "type" => "integer", "minimum" => 0 },
+        "date" => { "type" => "string", "format" => "date" },
+        "dateTime" => { "type" => "string", "format" => "date-time" },
+        "time" => { "type" => "string", "format" => "time" },
+        "anyURI" => { "type" => "string", "format" => "uri" },
+        "QName" => { "type" => "string" },
+      }.freeze
+
+      FACET_MAP = {
+        min_length: "minLength",
+        max_length: "maxLength",
+        min_inclusive: "minimum",
+        max_inclusive: "maximum",
+        min_exclusive: "exclusiveMinimum",
+        max_exclusive: "exclusiveMaximum",
+        pattern: "pattern",
+      }.freeze
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      # @return [Hash] JSON Schema 2020-12 document
+      def export
+        document = {
+          "$schema" => DRAFT,
+          "$defs" => {},
+        }
+        id = @schema.target_namespace
+        document["$id"] = id if id && !id.empty?
+
+        Array(@schema.complex_type).each do |complex_type|
+          next unless complex_type.name
+
+          document["$defs"][complex_type.name] =
+            complex_type_schema(complex_type)
+        end
+
+        Array(@schema.simple_type).each do |simple_type|
+          next unless simple_type.name
+
+          document["$defs"][simple_type.name] =
+            simple_type_schema(simple_type)
+        end
+
+        elements = Array(@schema.element)
+        elements.each do |element|
+          next unless element.name
+
+          document["$defs"][element.name] = element_schema(element)
+        end
+
+        unless elements.empty?
+          document["oneOf"] = elements.map do |element|
+            { "$ref" => "#/$defs/#{element.name}" }
+          end
+        end
+
+        document
+      end
+
+      # @return [String] pretty JSON
+      def to_json(pretty: true)
+        pretty ? JSON.pretty_generate(export) : JSON.generate(export)
+      end
+
+      private
+
+      def complex_type_schema(complex_type)
+        if complex_type.simple_content
+          return simple_content_schema(complex_type.simple_content)
+        end
+
+        schema = { "type" => "object" }
+        properties, required = properties_for(complex_type)
+        schema["properties"] = properties unless properties.empty?
+        schema["required"] = required unless required.empty?
+        schema["additionalProperties"] = false
+        schema
+      end
+
+      def simple_content_schema(simple_content)
+        base = simple_content.extension || simple_content.restriction
+        content = base && type_schema_for(base)
+        content ||= { "type" => "string" }
+        content.merge("type" => content["type"] || "string")
+      end
+
+      def properties_for(complex_type)
+        properties = {}
+        required = []
+
+        each_element_particle(complex_type) do |element|
+          name = element.name || element.ref
+          next unless name
+
+          max_occurs = element.max_occurs.to_s
+          max_occurs = "1" if max_occurs.empty?
+          min_occurs = element.min_occurs.to_s
+          min_occurs = "1" if min_occurs.empty?
+
+          properties[name] = element_schema(element)
+          if max_occurs != "1" && max_occurs != "0"
+            properties[name] = { "type" => "array", "items" => properties[name] }
+            required << name if min_occurs != "0"
+          elsif min_occurs != "0"
+            required << name
+          end
+        end
+
+        Array(complex_type.attribute).each do |attribute|
+          name = attribute.name || attribute.ref
+          next unless name
+
+          properties[name] = attribute_schema(attribute)
+          required << name if attribute.use == "required"
+        end
+
+        [properties, required]
+      end
+
+      def each_element_particle(node, &)
+        return unless node
+
+        %i[sequence choice all].each do |kind|
+          particle = node.public_send(kind) if node.respond_to?(kind)
+          next unless particle
+
+          Array(particle.element).each(&)
+          Array(particle.choice).each { |choice| each_element_particle(choice, &) }
+          Array(particle.sequence).each { |seq| each_element_particle(seq, &) }
+        end
+        return unless node.complex_content
+
+        %i[extension restriction].each do |kind|
+          part = node.complex_content.public_send(kind)
+          each_element_particle(part, &) if part
+        end
+      end
+
+      def element_schema(element)
+        schema = if element.complex_type
+                   complex_type_schema(element.complex_type)
+                 elsif element.simple_type
+                   simple_type_schema(element.simple_type)
+                 elsif element.type
+                   type_schema_for(element.type)
+                 else
+                   { "type" => "string" }
+                 end
+
+        schema = { "type" => ["null", schema["type"]] }.merge(schema.except("type")) if ["true", true].include?(element.nillable)
+
+        schema = { "const" => element.fixed } if element.fixed && !schema.key?("const")
+        schema
+      end
+
+      def attribute_schema(attribute)
+        schema = if attribute.simple_type
+                   simple_type_schema(attribute.simple_type)
+                 elsif attribute.type
+                   type_schema_for(attribute.type)
+                 else
+                   { "type" => "string" }
+                 end
+
+        schema = { "const" => attribute.fixed } if attribute.fixed
+        schema
+      end
+
+      def simple_type_schema(simple_type)
+        restriction = simple_type.restriction
+        return type_schema_for(restriction.base) if restriction.nil? || restriction.base.nil?
+
+        schema = type_schema_for(restriction.base)
+
+        Array(restriction.enumeration).each { |e| (schema["enum"] ||= []) << e.value }
+        FACET_MAP.each do |facet, json_key|
+          value = Array(restriction.public_send(facet)).first
+          schema[json_key] = facet_value(value, json_key) if value
+        rescue NoMethodError
+          next
+        end
+
+        schema
+      end
+
+      def facet_value(value, json_key)
+        return value.to_i if %w[minLength maxLength].include?(json_key)
+
+        return value.to_f if %w[minimum maximum exclusiveMinimum exclusiveMaximum].include?(json_key)
+
+        value
+      end
+
+      def type_schema_for(type_name)
+        local = type_name.to_s.split(":").last
+        builtin = BUILTIN_TYPES[local]
+        return builtin.dup if builtin
+
+        { "$ref" => "#/$defs/#{local}" }
+      end
+    end
+  end
+end

data/lib/lutaml/xsd/package_builder.rb

@@ -67,7 +67,7 @@ module Lutaml
           # Clear lazy XML element references that hold non-serializable
           # adapter nodes throughout the object graph.
           # lutaml-model's :lazy import_declaration_plan mode stores
-          # XmlElement references (containing Nokogiri nodes) on every
+          # XmlElement references (containing XML adapter nodes) on every
           # model instance during deserialization.
           clear_pending_plan_references(schema)
           Marshal.dump(schema)
@@ -201,7 +201,7 @@ module Lutaml
       private
 
       # Recursively walk an object graph and clear pending_plan_root_element
-      # on every Lutaml::Model::Serializable instance. This removes Nokogiri
+      # on every Lutaml::Model::Serializable instance. This removes XML
       # adapter_node references that prevent Marshal.dump from succeeding.
       #
       # @param root [Object] Root of the object graph to walk