xmi 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a22cfc924ac43626705d0adc35d932bff62d935001a2bde676ec3f0b639cf3fb
-  data.tar.gz: 35f16dfcc225665a88cf70d3fc1a9c5720c5fe4a1c64e3f7973b6fdb47197ead
+  metadata.gz: 588e344ea2df1c00d5050e7377bad54f7afca96e3925b327250cff8902a5027c
+  data.tar.gz: 56c69d3bc8056dffc1931af4c2d112db7b351e9fa39c4061b4073428be9b756a
 SHA512:
-  metadata.gz: c4d7b2c9e3b50521736fe7f44afe34a1f6340e201673516d83fe2067433043da4aa5e136ad6f9a9b62ba1d21d708b8e67c48bac1dda25392da20de755bdfbcaf
-  data.tar.gz: 87aeb1af821d63b69b037d35db8018e61e4398280ed8879d73de31efcd8195d59a89f2860464272cb107443190eeeb67d52342e84de40e4f07c8cdc4bd923f12
+  metadata.gz: 802a4c35900a1f3ed32a7d7ee0ad9b41a74686e0d1aedb5db318a1ffaa1bf9ca81f22d94d3672599bde39b56068ef4d5481242340552298bcd148eb479ee440d
+  data.tar.gz: '089817e9e7b880db5756a86023541012f5ef7a6e0b0f9161bc0a2e6a140bd915f69b9040d9175aadffd1ce3d0fee3fb2df2f2ed7d86a410d3cedfe64a114caeb'

data/.github/workflows/rake.yml

@@ -7,6 +7,9 @@ on:
   pull_request:
   workflow_dispatch:
 
+permissions:
+  contents: read
+
 jobs:
   rake:
     uses: metanorma/ci/.github/workflows/generic-rake.yml@main

data/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- All parse entry points (`Xmi.parse`, `Xmi.parse_with_version`,
+  `Xmi::Parsing.parse`, `Sparx::Root.parse_xml`) route through
+  `ParserPipeline`. Encoding repair no longer depends on which entry
+  point you pick — four of the five previously crashed on invalid
+  UTF-8. The dead `Sparx::Root.fix_encoding` duplicate is removed
+- The Root-level namespace scope is declared once
+  (`Xmi::Namespace::SCOPE`) and shared by `Xmi::Root` and
+  `Mappings::BaseMapping`; the two verbatim copies could drift
+  silently
+- The version modules (`V20110701`, `V20131001`, `V20161101`) declare
+  their table entry via `Versioned.define_version` instead of
+  repeating the register_id/namespace_classes/fallback_registers
+  boilerplate; each file now carries only its genuine delta
+- `OwnedAttribute`, `OwnedEnd`, and `OwnedParameter` inherit their
+  shared value-specification surface (uml_type + upper/lower/default
+  values + the four element mappings) from the new
+  `Xmi::Uml::ValueSpecs` base; serialized element order is pinned to
+  EA parity (type, lowerValue, upperValue)
+
 ### Fixed
 
 - Gemspec: restore the optimistic `~> 0.8.17` constraint on

data/CLAUDE.md

@@ -26,8 +26,22 @@ bundle exec rake
 
 # Interactive console for experimentation
 bin/console
+
+# Benchmarks (dev tooling under Xmi::Performance)
+bundle exec rake performance:quick    # fast, less accurate
+bundle exec rake performance:json     # JSON output
+```
+
+### RuboCop toolchain note
+
+`Gemfile.lock` is **gitignored** — each machine resolves its own versions, and CI installs lock-free (typically a newer RuboCop than a stale local lock resolves). If local rubocop disagrees with CI:
+
+```bash
+bundle update rubocop rubocop-ast rubocop-performance rubocop-rspec rubocop-rake
 ```
 
+Use the `rubocop:disable-next Cop` directive form (not `disable-next-line`) — it is the form current RuboCop accepts and requires for single-statement disables.
+
 ## Architecture Overview
 
 This gem converts XMI (XML Metadata Interchange) files into Ruby objects, specifically designed for Enterprise Architect generated XMI files.
@@ -37,18 +51,29 @@ This gem converts XMI (XML Metadata Interchange) files into Ruby objects, specif
 - **lutaml-model**: All serializable models inherit from `Lutaml::Model::Serializable`
 - **nokogiri**: XML parsing backend
 
-### Main Entry Point
+### Main Entry Point / Parse Pipeline
+
+Every public parse door routes through one module, `Xmi::ParserPipeline`
+(`lib/xmi/parser_pipeline.rb`):
 
-`Xmi::Sparx::Root.parse_xml(xml_content)` is the primary method to parse XMI files. It performs preprocessing before parsing:
+- `Xmi.parse(xml)` — auto version detection
+- `Xmi.parse_with_version(xml, version)`
+- `Xmi::Parsing.parse(xml, options)` — IO coercion, `:version`/`:register`/`:model_class` options
+- `Xmi::Sparx::Root.parse_xml(xml)` — also builds `Sparx::Index`
 
-1. `fix_encoding` - Fixes invalid UTF-8 byte sequences in the XML content
-2. `normalize_omg_namespace_versions` - Normalizes OMG namespace versions (XMI, UML) to canonical 20131001
-3. `resolve_relative_namespaces` - Replaces relative `xmlns` values with `targetNamespace` values
-4. `rename_ea_xmlns_attribute` - Renames `xmlns` attribute to `altered_xmlns` on EA-specific elements (see below)
+Pipeline steps: `FixEncoding` (repairs invalid UTF-8) →
+`RenameEaXmlnsAttribute` (see the EA xmlns quirk below) →
+`InitVersioning` → `ParseXml` (detects the version register, or uses
+`ctx[:register]` when a door resolved one) → `BuildIndex` (Root
+hierarchy only — custom `:model_class` models are skipped). Encoding
+repair runs no matter which door a consumer picks;
+`parser_pipeline_spec.rb` pins this for all doors.
 
-### OMG Namespace Version Normalization
+Adding a parse concern = adding a pipeline step, not editing doors.
 
-OMG publishes XMI and UML specifications with dated namespace URIs (e.g., `http://www.omg.org/spec/XMI/20110701`, `20131001`, `20161101`). This library normalizes all versions to `20131001` during parsing, allowing a single set of model classes to handle all versions.
+### OMG Namespace Version Handling
+
+OMG publishes XMI and UML specifications with dated namespace URIs (e.g., `http://www.omg.org/spec/XMI/20110701`, `20131001`, `20161101`). Documents of any version parse via per-version registers: `NamespaceDetector` scans the namespaces, `VersionRegistry.detect_register` picks the register (`V20110701` / `V20131001` / `V20161101`), and mixed-version documents extend the primary register's fallback chain. Model classes stay version-agnostic by using alias namespace classes that inherit from the 20131001 canonical versions.
 
 ### Enterprise Architect's Misuse of the `xmlns` Attribute
 
@@ -56,17 +81,7 @@ OMG publishes XMI and UML specifications with dated namespace URIs (e.g., `http:
 
 In standard XML, `xmlns` is a reserved attribute for namespace declarations. However, Enterprise Architect incorrectly uses `xmlns` as a **regular data attribute** on certain stereotype elements (e.g., `GML:ApplicationSchema`, `CityGML:ApplicationSchema`), storing arbitrary URI values unrelated to namespace declarations.
 
-This violates XML conventions and creates parsing conflicts—XML libraries treat `xmlns` as reserved. The library works around this by renaming `xmlns` to `altered_xmlns` before parsing:
-
-```xml
-<!-- EA-generated -->
-<GML:ApplicationSchema xmlns="http://some-value" ...>
-
-<!-- After preprocessing -->
-<GML:ApplicationSchema altered_xmlns="http://some-value" ...>
-```
-
-Model classes define `altered_xmlns` attributes to receive these values:
+This violates XML conventions and creates parsing conflicts—XML libraries treat `xmlns` as reserved. The workaround runs in the parse pipeline (`ParserPipeline::Steps::RenameEaXmlnsAttribute`): before parsing, `xmlns` is renamed to `altered_xmlns` on `GML:ApplicationSchema` and `CityGML:ApplicationSchema` tags only — legitimate namespace declarations are untouched. `Xmi::EaRoot` extension code generation applies the same rename when building classes from MDG XML that defines an attribute literally named `xmlns`. Pinned by `parser_pipeline_spec.rb` against the real `xmi-v2-4-2-default-with-gml.xmi` fixture.
 
 ```ruby
 class ApplicationSchema < Lutaml::Model::Serializable
@@ -74,13 +89,20 @@ class ApplicationSchema < Lutaml::Model::Serializable
 end
 ```
 
-### Namespace Architecture
+### EA Writes Attribute Names Verbatim
+
+Some EA attributes are written in non-camelCase spellings that must be
+mapped literally — "correcting" them breaks parsing. Examples:
+`package_name` and `associationclass` on `<extendedProperties>` (all
+lowercase, no case conversion), pinned by
+`spec/xmi/sparx/element/extended_properties_spec.rb`.
 
-**All XMI/UML namespace versions are normalized to 20131001 before parsing** (see `Root.replace_xmlns`).
+### Namespace Architecture
 
 Namespace classes are defined in:
 - `lib/xmi/namespace/omg.rb` - OMG namespaces (XMI, UML, UmlDi, UmlDc)
 - `lib/xmi/namespace/sparx.rb` - Sparx-specific profiles (SysPhS, GML, EaUml, CustomProfile, CityGML)
+- `lib/xmi/namespace.rb` - `Xmi::Namespace::SCOPE`: the canonical 10-namespace scope shared by `Xmi::Root`'s xml block and `Sparx::Mappings::BaseMapping` (pinned by `spec/xmi/namespace_scope_spec.rb`)
 
 Use version-agnostic alias classes that inherit from 20131001 versions:
 ```ruby
@@ -88,6 +110,18 @@ Use version-agnostic alias classes that inherit from 20131001 versions:
 ::Xmi::Namespace::Omg::Uml   # => inherits from Uml20131001
 ```
 
+### Version Registers
+
+`V20110701` / `V20131001` / `V20161101` are table entries: each calls
+`Versioned.define_version(register_id:, namespaces:, fallbacks:)` and
+keeps only its real delta (version-specific `Documentation`/`Extension`
+classes plus a `register_models` table). Adding an XMI version = a new
+table entry, not a new boilerplate file. `Versioned` (`lib/xmi/versioned.rb`)
+creates the `Lutaml::Model::Register`, binds namespaces, and runs
+registration; `VersionRegistry` (`lib/xmi/version_registry.rb`) maps
+version strings → registers and extends fallback chains for
+mixed-namespace documents.
+
 ### Custom Types with XML Namespace
 
 Custom types in `lib/xmi/type.rb` declare their XML namespace using the `xml do ... end` block:
@@ -113,6 +147,14 @@ UML Diagram Interchange elements (Bounds, Waypoint, Diagram,
 OwnedElement) inherit from `Xmi::UmlDi::Base` instead — same
 pattern, different namespace.
 
+`OwnedAttribute`, `OwnedEnd`, and `OwnedParameter` inherit from
+`Xmi::Uml::ValueSpecs`, which owns their shared value-specification
+surface: `uml_type` (`<type>` element) plus `upper_value` /
+`lower_value` / `default_value` with their polymorphic mappings.
+Inherited element mappings serialize before subclass mappings, so the
+EA-parity order (type, lowerValue, upperValue) comes from the base —
+subclasses declare only attributes.
+
 ```ruby
 # lib/xmi/uml/my_element.rb
 module Xmi
@@ -150,13 +192,14 @@ Two attributes use lutaml-model's polymorphic dispatch on `xmi:type`:
 - `PackagedElement.packaged_element` (and `UmlModel.packaged_element`) — dispatches to typed subclasses (`UmlClass`, `Association`, `Interface`, `InstanceSpecification`, etc.). Map: `Xmi::Uml::PACKAGED_ELEMENT_POLYMORPHIC_MAP` in `lib/xmi/uml/packaged_element.rb`.
 - `Slot.value`, `OwnedAttribute.upper_value`/`lower_value`/`default_value`, `OwnedEnd.upper_value`/`lower_value`/`default_value`, `OwnedParameter.upper_value`/`lower_value`/`default_value` — dispatch to ValueSpecification subclasses (`OpaqueExpression`, `LiteralString`, `LiteralInteger`, etc.). Map: `Xmi::Uml::VALUE_SPECIFICATION_POLYMORPHIC_MAP` in `lib/xmi/uml/value_specification.rb`.
 
-**Fallback contract:** unknown or missing `xmi:type` resolves to the abstract base (`PackagedElement` / `ValueSpecification`) via the class_map's Hash default value — no crash. Locked in by `spec/xmi/uml/polymorphic_map_contract_spec.rb` and `spec/xmi/uml/polymorphic_robustness_spec.rb`. Two paths land at the base: a missing discriminator short-circuits upstream (the declared attribute type is used); an unknown discriminator hits the Hash default. Residual upstream gap — modelling `xmi:type` and unprefixed `type` as separate slots on one element — is tracked in lutaml-model#744.
+**Fallback contract:** unknown or missing `xmi:type` resolves to the abstract base (`PackagedElement` / `ValueSpecification`) via the class_map's Hash default value — no crash. Locked in by `spec/xmi/uml/polymorphic_map_contract_spec.rb` and `spec/xmi/uml/polymorphic_robustness_spec.rb`. Two paths land at the base: a missing discriminator short-circuits upstream (the declared attribute type is used); an unknown discriminator hits the Hash default. Residual upstream gap — modelling `xmi:type` and unprefixed `type` as separate slots on one element — is tracked in lutaml-model#758.
 
 ### Key Files
 
 | File | Purpose |
 |------|---------|
 | `lib/xmi.rb` | Main entry point, loads dependencies and configures XML adapter |
+| `lib/xmi/parser_pipeline.rb` | The parse pipeline — the one module behind every public parse door |
 | `lib/xmi/sparx.rb` | Module with autoload declarations for Sparx components |
 | `lib/xmi/sparx/root.rb` | Main `Root` class with parsing and namespace normalization |
 | `lib/xmi/root.rb` | Base `Root` class with common XMI attributes |
@@ -166,11 +209,14 @@ Two attributes use lutaml-model's polymorphic dispatch on `xmi:type`:
 | `lib/xmi/uml_di/base.rb` | `Xmi::UmlDi::Base` — common boilerplate for UMLDI classes |
 | `lib/xmi/uml/packaged_element.rb` | `PackagedElement` + `PACKAGED_ELEMENT_POLYMORPHIC_MAP` |
 | `lib/xmi/uml/value_specification.rb` | `ValueSpecification` abstract base + `VALUE_SPECIFICATION_POLYMORPHIC_MAP` |
+| `lib/xmi/uml/value_specs.rb` | `Xmi::Uml::ValueSpecs` — shared value surface for OwnedAttribute/OwnedEnd/OwnedParameter |
 | `lib/xmi/ea_root.rb` | Dynamic extension loading from MDG XML |
 | `lib/xmi/type.rb` | Custom types with namespace declarations (XmiId, XmiType, etc.) |
 | `lib/xmi/namespace/omg.rb` | OMG namespace classes (XMI, UML, UmlDi, UmlDc) |
 | `lib/xmi/namespace/sparx.rb` | Sparx-specific profile namespaces |
 | `lib/xmi/namespace_registry.rb` | URI-to-class mapping for namespace lookup |
+| `lib/xmi/versioned.rb` | Version-register DSL: `define_version` table entries + `register_models` helper |
+| `lib/xmi/version_registry.rb` | Version string → register mapping, mixed-namespace fallback chains |
 
 ### Collection Value Maps
 
@@ -188,8 +234,10 @@ A shared constant is available at `Xmi::Sparx::VALUE_MAP`.
 
 ## Known Issues
 
-Attribute deserialization in lutaml-model is not namespace-disjoint: same-local-name attributes in different namespaces collapse into one model slot, document-order dependent. This affects modelling `xmi:type` (the XMI discriminator) and unprefixed `type` (Sparx's classifier reference) as separate attributes on one element. Tracked in lutaml-model#744 with a repro. Serialization is not affected — it is already namespace-disjoint.
+Attribute deserialization in lutaml-model is not namespace-disjoint under element-level namespaces: same-local-name attributes in different namespaces collapse into one model slot, document-order dependent (last spelling wins). This affects modelling `xmi:type` (the XMI discriminator) and unprefixed `type` (Sparx's classifier reference) as separate attributes on one element — see the class docstring on `OwnedParameter`. Tracked in lutaml-model#758 with a repro; `spec/xmi/uml/owned_parameter_spec.rb` pins the current behavior in both input orders.
+
+The `lutaml-model` gemspec constraint is itself pinned by `spec/xmi_gemspec_spec.rb` — changing the dependency range is a deliberate act that updates that spec.
 
 ## Limitations
 
-This gem is designed for Enterprise Architect generated XMI files and may not work with XMI from other tools. Some EA-specific elements (e.g., `GML:ApplicationSchema`) use `xmlns` as an attribute, which is renamed to `altered_xmlns` during preprocessing to avoid conflicts with Lutaml::Model internals.
+This gem is designed for Enterprise Architect generated XMI files and may not work with XMI from other tools.

data/lib/xmi/namespace.rb

@@ -5,5 +5,23 @@ module Xmi
     autoload :Omg, "xmi/namespace/omg"
     autoload :Sparx, "xmi/namespace/sparx"
     autoload :Dynamic, "xmi/namespace/dynamic"
+
+    # Canonical namespace scope for XMI document parsing — every
+    # namespace a Root-level mapping may resolve against, in
+    # resolution order (OMG core first, then Sparx profiles).
+    # Declared once; consumed by both Xmi::Root's xml block and
+    # Sparx::Mappings::BaseMapping.
+    SCOPE = [
+      Omg::Xmi,
+      Omg::Uml,
+      Omg::UmlDi,
+      Omg::UmlDc,
+      Sparx::Extension,
+      Sparx::Gml,
+      Sparx::CustomProfile,
+      Sparx::SysPhS,
+      Sparx::EaUml,
+      Sparx::CityGml,
+    ].freeze
   end
 end

data/lib/xmi/parser_pipeline.rb

@@ -26,6 +26,22 @@ module Xmi
         end
       end
 
+      # EA misuses the reserved xmlns attribute as a DATA attribute on
+      # GML:/CityGML:ApplicationSchema stereotype elements (values
+      # unrelated to real namespace declarations). XML parsers treat
+      # xmlns as a namespace declaration, so without renaming, the
+      # value is silently dropped. Restored from the original
+      # replace_ea_xmlns preprocessing (commit 8da3bfb), which was
+      # lost in the lutaml-model 0.8 upgrade.
+      module RenameEaXmlnsAttribute
+        EA_XMLNS_TAG = %r{(<(?:GML|CityGML):ApplicationSchema[^>]*?)xmlns="([^"]*)"}
+
+        def self.call(ctx)
+          ctx[:xml] = ctx[:xml].gsub(EA_XMLNS_TAG, '\1altered_xmlns="\2"')
+          ctx
+        end
+      end
+
       module InitVersioning
         def self.call(ctx)
           Xmi.init_versioning!
@@ -36,16 +52,22 @@ module Xmi
       module ParseXml
         def self.call(ctx)
           root_class = ctx[:root_class]
-          ctx[:root] = VersionRegistry.parse_with_detected_version(
-            ctx[:xml], root_class
-          )
+          ctx[:root] = if ctx[:register]
+                         root_class.from_xml(ctx[:xml], register: ctx[:register])
+                       else
+                         VersionRegistry.parse_with_detected_version(
+                           ctx[:xml], root_class
+                         )
+                       end
           ctx
         end
       end
 
       module BuildIndex
         def self.call(ctx)
-          ctx[:root].build_index
+          # Only the Root hierarchy carries an index; custom model
+          # classes parsed through the pipeline are left alone.
+          ctx[:root].build_index if ctx[:root].is_a?(::Xmi::Root)
           ctx
         end
       end
@@ -53,6 +75,7 @@ module Xmi
 
     DEFAULT_STEPS = [
       Steps::FixEncoding,
+      Steps::RenameEaXmlnsAttribute,
       Steps::InitVersioning,
       Steps::ParseXml,
       Steps::BuildIndex,

data/lib/xmi/parsing.rb

@@ -29,17 +29,14 @@ module Xmi
       def parse(xml, options = {})
         xml_content = xml.is_a?(String) ? xml : xml.read
 
-        Xmi.init_versioning! unless Xmi.versioning_initialized?
-
-        register = determine_register(xml_content, options)
-        model_class = options[:model_class] || Root
+        ctx = {
+          xml: xml_content,
+          root_class: options[:model_class] || Root,
+        }
+        register = explicit_register(options)
+        ctx[:register] = register if register
 
-        if register
-          model_class.from_xml(xml_content, register: register)
-        else
-          # Fallback to default parsing (existing behavior)
-          model_class.from_xml(xml_content)
-        end
+        ParserPipeline.run(ctx)[:root]
       end
 
       # @api public
@@ -88,28 +85,20 @@ module Xmi
 
       private
 
-      # Determine the appropriate register for parsing
+      # Resolve an explicitly requested register from options
+      #
+      # Returns nil when neither :register nor :version is given, leaving
+      # version detection to the pipeline.
       #
-      # @param xml_content [String] XML content
       # @param options [Hash] Options hash
       # @return [Lutaml::Model::Register, nil]
-      def determine_register(xml_content, options)
-        # Explicit register takes precedence
+      def explicit_register(options)
         return options[:register] if options[:register]
 
-        # Explicit version
-        if options[:version]
-          reg = VersionRegistry.register_for_version(options[:version])
-          unless reg
-            raise ArgumentError,
-                  "Unknown version: #{options[:version]}"
-          end
-
-          return reg
-        end
+        return unless options[:version]
 
-        # Auto-detect from XML content
-        VersionRegistry.detect_register(xml_content)
+        VersionRegistry.register_for_version(options[:version]) ||
+          raise(ArgumentError, "Unknown version: #{options[:version]}")
       end
     end
   end

data/lib/xmi/root.rb

@@ -29,18 +29,7 @@ module Xmi
     xml do
       root "XMI"
       namespace ::Xmi::Namespace::Omg::Xmi
-      namespace_scope [
-        ::Xmi::Namespace::Omg::Xmi,
-        ::Xmi::Namespace::Omg::Uml,
-        ::Xmi::Namespace::Omg::UmlDi,
-        ::Xmi::Namespace::Omg::UmlDc,
-        ::Xmi::Namespace::Sparx::Extension,
-        ::Xmi::Namespace::Sparx::Gml,
-        ::Xmi::Namespace::Sparx::CustomProfile,
-        ::Xmi::Namespace::Sparx::SysPhS,
-        ::Xmi::Namespace::Sparx::EaUml,
-        ::Xmi::Namespace::Sparx::CityGml,
-      ]
+      namespace_scope ::Xmi::Namespace::SCOPE
 
       XmiIdentity.apply_xml_mappings(self)
 

data/lib/xmi/sparx/mappings/base_mapping.rb

@@ -17,18 +17,7 @@ module Xmi
           # Set the default namespace for element name resolution
           namespace ::Xmi::Namespace::Omg::Xmi
 
-          namespace_scope [
-            ::Xmi::Namespace::Omg::Xmi,
-            ::Xmi::Namespace::Omg::Uml,
-            ::Xmi::Namespace::Omg::UmlDi,
-            ::Xmi::Namespace::Omg::UmlDc,
-            ::Xmi::Namespace::Sparx::Extension,
-            ::Xmi::Namespace::Sparx::SysPhS,
-            ::Xmi::Namespace::Sparx::Gml,
-            ::Xmi::Namespace::Sparx::EaUml,
-            ::Xmi::Namespace::Sparx::CustomProfile,
-            ::Xmi::Namespace::Sparx::CityGml,
-          ]
+          namespace_scope ::Xmi::Namespace::SCOPE
 
           VM = ::Xmi::VALUE_MAP
 

data/lib/xmi/sparx/root.rb

@@ -37,22 +37,6 @@ module Xmi
           )
           ctx[:root]
         end
-
-        # Fix invalid UTF-8 encoding in the XML content.
-        #
-        # Some EA-generated XMI files contain invalid UTF-8 byte sequences
-        # that would cause parsing failures. This method replaces invalid
-        # bytes with placeholder characters.
-        #
-        # @param xml_content [String] The raw XML content
-        # @return [String] The XML content with valid UTF-8 encoding
-        def fix_encoding(xml_content)
-          return xml_content if xml_content.valid_encoding?
-
-          xml_content
-            .encode("UTF-16be", invalid: :replace, replace: "?")
-            .encode("UTF-8")
-        end
       end
 
       # Use the reusable BaseMapping class instead of eval hack

data/lib/xmi/uml/owned_attribute.rb

@@ -2,7 +2,7 @@
 
 module Xmi
   module Uml
-    class OwnedAttribute < Base
+    class OwnedAttribute < ValueSpecs
       attribute :association, :string
       attribute :name, :string
       attribute :visibility, :string
@@ -12,14 +12,10 @@ module Xmi
       attribute :is_unique, :boolean
       attribute :is_read_only, :boolean
       # `default` is the XMI attribute form (string shortcut);
-      # `default_value` below is the child <defaultValue> element
-      # (ValueSpecification). UML 2.5 Property carries both shapes.
+      # `default_value` (from ValueSpecs) is the child <defaultValue>
+      # element (ValueSpecification). UML 2.5 Property carries both shapes.
       attribute :default, :string
       attribute :aggregation, :string
-      attribute :uml_type, Uml::Type
-      attribute :upper_value, ValueSpecification, polymorphic: true
-      attribute :lower_value, ValueSpecification, polymorphic: true
-      attribute :default_value, ValueSpecification, polymorphic: true
 
       xml do
         root "ownedAttribute"
@@ -33,15 +29,6 @@ module Xmi
         map_attribute "isReadOnly", to: :is_read_only
         map_attribute "default", to: :default
         map_attribute "aggregation", to: :aggregation
-
-        map_element "type", to: :uml_type
-        # Sparx EA emits lowerValue before upperValue.
-        map_element "lowerValue", to: :lower_value,
-                                  polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
-        map_element "upperValue", to: :upper_value,
-                                  polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
-        map_element "defaultValue", to: :default_value,
-                                    polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
       end
     end
   end

data/lib/xmi/uml/owned_end.rb

@@ -2,16 +2,12 @@
 
 module Xmi
   module Uml
-    class OwnedEnd < Base
+    class OwnedEnd < ValueSpecs
       attribute :association, :string
       attribute :name, :string
       attribute :visibility, :string
       attribute :aggregation, :string
-      attribute :uml_type, Uml::Type
       attribute :member_end, :string
-      attribute :upper_value, ValueSpecification, polymorphic: true
-      attribute :lower_value, ValueSpecification, polymorphic: true
-      attribute :default_value, ValueSpecification, polymorphic: true
       attribute :is_composite, :boolean
 
       xml do
@@ -22,15 +18,6 @@ module Xmi
         map_attribute "aggregation", to: :aggregation
         map_attribute "memberEnd", to: :member_end
         map_attribute "isComposite", to: :is_composite
-
-        map_element "type", to: :uml_type
-        # Sparx EA emits lowerValue before upperValue.
-        map_element "lowerValue", to: :lower_value,
-                                  polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
-        map_element "upperValue", to: :upper_value,
-                                  polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
-        map_element "defaultValue", to: :default_value,
-                                    polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
       end
     end
   end

data/lib/xmi/uml/owned_parameter.rb

@@ -2,7 +2,7 @@
 
 module Xmi
   module Uml
-    class OwnedParameter < Base
+    class OwnedParameter < ValueSpecs
       attribute :name, :string
       # These are two DIFFERENT attributes that collide here:
       #   xmi:type="uml:Parameter"  — the XMI metaclass discriminator
@@ -27,9 +27,6 @@ module Xmi
       attribute :is_ordered, :boolean
       attribute :is_unique, :boolean
       attribute :effect, :string
-      attribute :upper_value, ValueSpecification, polymorphic: true
-      attribute :lower_value, ValueSpecification, polymorphic: true
-      attribute :default_value, ValueSpecification, polymorphic: true
 
       xml do
         root "ownedParameter"
@@ -40,14 +37,6 @@ module Xmi
         map_attribute "isOrdered", to: :is_ordered
         map_attribute "isUnique", to: :is_unique
         map_attribute "effect", to: :effect
-
-        # Sparx EA emits lowerValue before upperValue.
-        map_element "lowerValue", to: :lower_value,
-                                  polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
-        map_element "upperValue", to: :upper_value,
-                                  polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
-        map_element "defaultValue", to: :default_value,
-                                    polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
       end
     end
   end

data/lib/xmi/uml/value_specs.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Uml
+    # Shared value-specification surface for typed structural features:
+    # the classifier reference (<type> element) plus the multiplicity
+    # bounds and default value (<lowerValue>/<upperValue>/<defaultValue>).
+    #
+    # Element order matches Sparx EA output: type first, then values,
+    # lowerValue before upperValue. Inherited element mappings
+    # serialize before subclass mappings, so subclasses (OwnedAttribute,
+    # OwnedEnd, OwnedParameter) declare only attributes and keep this
+    # output order.
+    class ValueSpecs < Base
+      attribute :uml_type, Uml::Type
+      attribute :upper_value, ValueSpecification, polymorphic: true
+      attribute :lower_value, ValueSpecification, polymorphic: true
+      attribute :default_value, ValueSpecification, polymorphic: true
+
+      xml do
+        map_element "type", to: :uml_type
+        map_element "lowerValue", to: :lower_value,
+                                  polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
+        map_element "upperValue", to: :upper_value,
+                                  polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
+        map_element "defaultValue", to: :default_value,
+                                    polymorphic: VALUE_SPECIFICATION_POLYMORPHIC_MAP
+      end
+    end
+  end
+end

data/lib/xmi/uml.rb

@@ -10,6 +10,7 @@ module Xmi
     autoload :UpperValue, "xmi/uml/upper_value"
     autoload :LowerValue, "xmi/uml/lower_value"
     autoload :ValueSpecification, "xmi/uml/value_specification"
+    autoload :ValueSpecs, "xmi/uml/value_specs"
     autoload :LiteralString, "xmi/uml/literal_string"
     autoload :LiteralInteger, "xmi/uml/literal_integer"
     autoload :LiteralBoolean, "xmi/uml/literal_boolean"

data/lib/xmi/v20110701.rb

@@ -8,29 +8,17 @@ module Xmi
   module V20110701
     extend Versioned
 
-    # Register ID
-    def self.register_id
-      :xmi_20110701
-    end
-
-    # Namespace classes this version binds to
-    def self.namespace_classes
-      [
+    define_version(
+      register_id: :xmi_20110701,
+      namespaces: [
         Xmi::Namespace::Omg::Xmi20110701,
         Xmi::Namespace::Omg::Uml20110701,
-      ]
-    end
-
-    # Fallback chain: common → default
-    def self.fallback_registers
-      %i[xmi_common default]
-    end
+      ],
+    )
 
     # Register all models for this version
     def self.register_models!
-      # Register version-specific models
-      register.register_model(Extension, id: :extension)
-      register.register_model(Documentation, id: :documentation)
+      register_models extension: Extension, documentation: Documentation
     end
 
     # XMI 2.1 Extension element

data/lib/xmi/v20131001.rb

@@ -8,33 +8,22 @@ module Xmi
   module V20131001
     extend Versioned
 
-    # Register ID
-    def self.register_id
-      :xmi_20131001
-    end
-
-    # Namespace classes this version binds to
-    def self.namespace_classes
-      [
+    # V20110701 in the chain: V20131001 reuses its Extension (same structure)
+    define_version(
+      register_id: :xmi_20131001,
+      namespaces: [
         Xmi::Namespace::Omg::Xmi20131001,
         Xmi::Namespace::Omg::Uml20131001,
         Xmi::Namespace::Omg::UmlDi20131001,
         Xmi::Namespace::Omg::UmlDc20131001,
-      ]
-    end
-
-    # Fallback chain: V20110701 → common → default
-    # This allows V20131001 to use V20110701's Extension (same structure)
-    def self.fallback_registers
-      %i[xmi_20110701 xmi_common default]
-    end
+      ],
+      fallbacks: %i[xmi_20110701 xmi_common default],
+    )
 
     # Register all models for this version
     def self.register_models!
       # Extension is same as V20110701 - will be found via fallback
-
-      # Documentation is different - register our version
-      register.register_model(Documentation, id: :documentation)
+      register_models documentation: Documentation
     end
 
     # XMI 2.5.1 Documentation element

data/lib/xmi/v20161101.rb

@@ -8,32 +8,22 @@ module Xmi
   module V20161101
     extend Versioned
 
-    # Register ID
-    def self.register_id
-      :xmi_20161101
-    end
-
-    # Namespace classes this version binds to
-    def self.namespace_classes
-      [
+    define_version(
+      register_id: :xmi_20161101,
+      namespaces: [
         Xmi::Namespace::Omg::Xmi20161101,
         Xmi::Namespace::Omg::Uml20161101,
         Xmi::Namespace::Omg::UmlDi20161101,
         Xmi::Namespace::Omg::UmlDc20161101,
-      ]
-    end
-
-    # Fallback chain: V20131001 → V20110701 → common → default
-    def self.fallback_registers
-      %i[xmi_20131001 xmi_20110701 xmi_common default]
-    end
+      ],
+      fallbacks: %i[xmi_20131001 xmi_20110701 xmi_common default],
+    )
 
     # Register all models for this version
     def self.register_models!
-      # Extension is different in 2.5.2 - register our version
-      register.register_model(Extension, id: :extension)
-
+      # Extension is different in 2.5.2 - register our version.
       # Documentation is same as V20131001 - will be found via fallback
+      register_models extension: Extension
     end
 
     # XMI 2.5.2 Extension element

data/lib/xmi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Xmi
-  VERSION = "0.7.3"
+  VERSION = "0.7.4"
 end

data/lib/xmi/versioned.rb

@@ -4,26 +4,30 @@ module Xmi
   # Base module for version-specific XMI model trees.
   #
   # Each version module (V20110701, V20131001, V20161101) extends this
-  # and provides its own register and namespace bindings.
+  # and declares its table entry via define_version, keeping only its
+  # real delta (version-specific model classes and what to register).
   #
   # @example
   #   module Xmi::V20131001
   #     extend Xmi::Versioned
   #
-  #     def self.register_id
-  #       :xmi_20131001
-  #     end
-  #
-  #     def self.namespace_classes
-  #       [Xmi::Namespace::Omg::Xmi20131001, Xmi::Namespace::Omg::Uml20131001]
-  #     end
+  #     define_version(
+  #       register_id: :xmi_20131001,
+  #       namespaces: [Xmi::Namespace::Omg::Xmi20131001,
+  #                    Xmi::Namespace::Omg::Uml20131001],
+  #       fallbacks: %i[xmi_20110701 xmi_common default],
+  #     )
   #
   #     def self.register_models!
-  #       # Register version-specific models
+  #       register_models documentation: Documentation
   #     end
   #   end
   #
   module Versioned
+    # Fallback chain used when a version declares none: the common
+    # register, then the default register.
+    DEFAULT_FALLBACKS = %i[xmi_common default].freeze
+
     # @api public
     # Called when a module extends Versioned
     def self.extended(base)
@@ -33,6 +37,23 @@ module Xmi
       end
     end
 
+    # @api public
+    # Declare this version's table entry.
+    #
+    # Defines register_id, namespace_classes, and fallback_registers on
+    # the extending module. Versions that extend Versioned without
+    # calling this keep the NotImplementedError contract below.
+    #
+    # @param register_id [Symbol] Register ID for this version
+    # @param namespaces [Array<Class>] XmlNamespace classes to bind
+    # @param fallbacks [Array<Symbol>] Fallback register IDs
+    # @return [void]
+    def define_version(register_id:, namespaces:, fallbacks: DEFAULT_FALLBACKS)
+      define_singleton_method(:register_id) { register_id }
+      define_singleton_method(:namespace_classes) { namespaces }
+      define_singleton_method(:fallback_registers) { fallbacks }
+    end
+
     # @api public
     # Get the register for this version
     #
@@ -87,6 +108,15 @@ module Xmi
             "Each version must implement #register_models!"
     end
 
+    # @api public
+    # Bulk-register models from a table.
+    #
+    # @param models [Hash{Symbol => Class}] id → model class
+    # @return [void]
+    def register_models(models)
+      models.each { |id, klass| register.register_model(klass, id: id) }
+    end
+
     # @api public
     # Get the register ID for this version
     #

data/lib/xmi.rb

@@ -101,8 +101,7 @@ module Xmi
     # @param xml_content [String] XML content
     # @return [Root] Parsed XMI document
     def parse(xml_content)
-      init_versioning!
-      VersionRegistry.parse_with_detected_version(xml_content, Root)
+      ParserPipeline.run({ xml: xml_content, root_class: Root })[:root]
     end
 
     # @api public
@@ -112,11 +111,12 @@ module Xmi
     # @param version [String] Version string (e.g., "20131001")
     # @return [Root] Parsed XMI document
     def parse_with_version(xml_content, version)
-      init_versioning!
       register = VersionRegistry.register_for_version(version)
       raise ArgumentError, "Unknown version: #{version}" unless register
 
-      Root.from_xml(xml_content, register: register)
+      ParserPipeline.run(
+        { xml: xml_content, root_class: Root, register: register },
+      )[:root]
     end
 
     # @api public

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xmi
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-26 00:00:00.000000000 Z
+date: 2026-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -211,6 +211,7 @@ files:
 - lib/xmi/uml/upper_value.rb
 - lib/xmi/uml/usage.rb
 - lib/xmi/uml/value_specification.rb
+- lib/xmi/uml/value_specs.rb
 - lib/xmi/uml/waypoint.rb
 - lib/xmi/uml_di.rb
 - lib/xmi/uml_di/base.rb