xmi 0.3.21 → 0.5.0

data/lib/xmi/v20110701.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Xmi
+  # XMI 2.1 (July 2011) version-specific models
+  #
+  # This is the base version that others fall back to for common models.
+  #
+  module V20110701
+    extend Versioned
+
+    # Register ID
+    def self.register_id
+      :xmi_20110701
+    end
+
+    # Namespace classes this version binds to
+    def self.namespace_classes
+      [
+        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)
+    end
+
+    # XMI 2.1 Extension element
+    #
+    # Structure is identical in 2.1 and 2.5.1, so V20131001 reuses this.
+    #
+    class Extension < Lutaml::Model::Serializable
+      attribute :extender, :string
+      attribute :extender_id, :string
+
+      xml do
+        root "Extension"
+        namespace Xmi::Namespace::Omg::Xmi20110701
+
+        map_attribute "extender", to: :extender
+        map_attribute "extenderID", to: :extender_id
+      end
+    end
+
+    # XMI 2.1 Documentation element
+    #
+    # Structure differs from 2.5.1, so V20131001 defines its own.
+    #
+    class Documentation < Lutaml::Model::Serializable
+      attribute :contact, :string
+      attribute :exporter, :string
+      attribute :exporter_version, :string
+      attribute :exporter_id, :string
+      attribute :timestamp, :string
+      attribute :remarks, :string
+
+      xml do
+        root "Documentation"
+        namespace Xmi::Namespace::Omg::Xmi20110701
+
+        map_element "contact", to: :contact
+        map_element "exporter", to: :exporter
+        map_element "exporterVersion", to: :exporter_version
+        map_element "exporterID", to: :exporter_id
+        map_element "timestamp", to: :timestamp
+        map_element "remarks", to: :remarks
+      end
+    end
+
+    # Auto-register with VersionRegistry
+    VersionRegistry.register_version("20110701", self)
+  end
+end

data/lib/xmi/v20131001.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Xmi
+  # XMI 2.5.1 (October 2013) version-specific models
+  #
+  # Falls back to V20110701 for shared models (like Extension).
+  #
+  module V20131001
+    extend Versioned
+
+    # Register ID
+    def self.register_id
+      :xmi_20131001
+    end
+
+    # Namespace classes this version binds to
+    def self.namespace_classes
+      [
+        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
+
+    # 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)
+    end
+
+    # XMI 2.5.1 Documentation element
+    #
+    # Different structure from 2.1 - includes additional fields.
+    #
+    class Documentation < Lutaml::Model::Serializable
+      attribute :contact, :string
+      attribute :exporter, :string
+      attribute :exporter_version, :string
+      attribute :exporter_id, :string  # NEW in 2.5.1
+      attribute :timestamp, :string    # NEW in 2.5.1
+      attribute :remarks, :string
+
+      xml do
+        root "Documentation"
+        namespace Xmi::Namespace::Omg::Xmi20131001
+
+        map_element "contact", to: :contact
+        map_element "exporter", to: :exporter
+        map_element "exporterVersion", to: :exporter_version
+        map_element "exporterID", to: :exporter_id
+        map_element "timestamp", to: :timestamp
+        map_element "remarks", to: :remarks
+      end
+    end
+
+    # Auto-register with VersionRegistry
+    VersionRegistry.register_version("20131001", self)
+  end
+end

data/lib/xmi/v20161101.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Xmi
+  # XMI 2.5.2 (November 2016) version-specific models
+  #
+  # Falls back to V20131001 and V20110701 for shared models.
+  #
+  module V20161101
+    extend Versioned
+
+    # Register ID
+    def self.register_id
+      :xmi_20161101
+    end
+
+    # Namespace classes this version binds to
+    def self.namespace_classes
+      [
+        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
+
+    # 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)
+
+      # Documentation is same as V20131001 - will be found via fallback
+    end
+
+    # XMI 2.5.2 Extension element
+    #
+    # Different structure from 2.1/2.5.1 - includes additional fields.
+    #
+    class Extension < Lutaml::Model::Serializable
+      attribute :extender, :string
+      attribute :extender_id, :string
+      attribute :extender_version, :string # NEW in 2.5.2
+
+      xml do
+        root "Extension"
+        namespace Xmi::Namespace::Omg::Xmi20161101
+
+        map_attribute "extender", to: :extender
+        map_attribute "extenderID", to: :extender_id
+        map_attribute "extenderVersion", to: :extender_version
+      end
+    end
+
+    # Auto-register with VersionRegistry
+    VersionRegistry.register_version("20161101", self)
+  end
+end

data/lib/xmi/version.rb

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

data/lib/xmi/version_registry.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Xmi
+  # Registry for XMI version-specific model trees.
+  #
+  # Manages the mapping between XMI versions and their registers.
+  #
+  # @example
+  #   # Get register for a specific version
+  #   register = Xmi::VersionRegistry.register_for_version("20131001")
+  #
+  # @example
+  #   # Detect version from XML
+  #   register = Xmi::VersionRegistry.detect_register(xml_content)
+  #
+  module VersionRegistry
+    # Map of version string => version module
+    @versions = {
+      "20110701" => nil,  # Set during V20110701 init
+      "20131001" => nil,  # Set during V20131001 init
+      "20161101" => nil, # Set during V20161101 init
+    }.freeze
+
+    class << self
+      # @api public
+      # Get register for a specific XMI version
+      #
+      # @param version [String] Version string (e.g., "20131001")
+      # @return [Lutaml::Model::Register, nil]
+      def register_for_version(version)
+        version_module = @versions[version]
+        return nil unless version_module
+
+        version_module.register
+      end
+
+      # @api public
+      # Get register for a namespace URI
+      #
+      # @param namespace_uri [String] The namespace URI
+      # @return [Lutaml::Model::Register, nil]
+      def register_for_namespace(namespace_uri)
+        Lutaml::Model::GlobalContext.register_for_namespace(namespace_uri)
+      end
+
+      # @api public
+      # Register a version module
+      #
+      # @param version [String] Version string
+      # @param mod [Module] The version module
+      # @return [void]
+      def register_version(version, mod)
+        @versions = @versions.merge(version => mod)
+      end
+
+      # @api public
+      # Get all registered versions
+      #
+      # @return [Array<String>]
+      def available_versions
+        @versions.keys
+      end
+
+      # @api public
+      # Get the version module for a version string
+      #
+      # @param version [String] Version string
+      # @return [Module, nil]
+      def version_module(version)
+        @versions[version]
+      end
+
+      # @api public
+      # Detect version from XML content and return appropriate register
+      #
+      # For mixed namespace documents (e.g., XMI=20131001, UML=20161101), this
+      # extends the primary register's fallback chain to include registers for
+      # additional namespace versions, enabling correct type resolution.
+      #
+      # @param xml_content [String] XML content
+      # @return [Lutaml::Model::Register, nil]
+      def detect_register(xml_content)
+        versions = NamespaceDetector.detect_versions(xml_content)
+        xmi_version = versions[:xmi]
+
+        return nil unless xmi_version
+
+        primary_register = register_for_version(xmi_version)
+        return nil unless primary_register
+
+        # Handle mixed namespace documents (e.g., XMI=20131001 but UML=20161101).
+        # We need to ensure the primary register's fallback chain includes
+        # registers for any additional namespace versions, and bind those
+        # namespace URIs to the primary register so type resolution works.
+        all_versions = [versions[:xmi], versions[:uml], versions[:umldi],
+                        versions[:umldc]].compact.uniq
+
+        extend_fallback_for_mixed_namespaces(primary_register, all_versions) if all_versions.length > 1
+
+        primary_register
+      end
+
+      # @api public
+      # Parse XML with automatic version detection
+      #
+      # @param xml_content [String] XML content
+      # @param model_class [Class] The model class to parse into
+      # @return [Object] Parsed model instance
+      def parse_with_detected_version(xml_content, model_class)
+        register = detect_register(xml_content)
+
+        if register
+          model_class.from_xml(xml_content, register: register)
+        else
+          # Fallback to default parsing (existing behavior)
+          model_class.from_xml(xml_content)
+        end
+      end
+
+      # Handle mixed namespace documents by binding additional namespace URIs
+      # to the primary register and extending its fallback chain.
+      #
+      # The namespace binding allows the primary register to handle elements
+      # from additional namespace versions. The fallback chain extension allows
+      # type resolution for types that exist only in those additional registers.
+      #
+      # Cycles are prevented by checking that the additional register's fallback
+      # chain doesn't include the primary register (which would create a cycle).
+      #
+      # @param primary_register [Lutaml::Model::Register] The primary register
+      # @param all_versions [Array<String>] All detected namespace versions
+      # @return [void]
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def extend_fallback_for_mixed_namespaces(primary_register, all_versions)
+        xmi_version = all_versions.first
+        other_versions = all_versions.drop(1)
+
+        other_versions.each do |ver|
+          next if ver == xmi_version
+
+          reg = register_for_version(ver)
+          next unless reg
+
+          # Bind additional namespace URIs to the primary register using
+          # proper namespace classes from NamespaceRegistry.
+          reg.bound_namespace_uris.each do |uri|
+            next if primary_register.handles_namespace?(uri)
+
+            ns_class = NamespaceRegistry.resolve(uri)
+            next unless ns_class
+
+            primary_register.bind_namespace(ns_class)
+          end
+
+          # Extend fallback chain only if it won't create a cycle.
+          # A cycle would occur if reg's fallback chain includes primary_register.
+          # We check this by seeing if primary_register.id appears in reg's fallback.
+          primary_register.fallback << reg.id unless reg.fallback.include?(primary_register.id)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+  end
+end

data/lib/xmi/versioned.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+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.
+  #
+  # @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
+  #
+  #     def self.register_models!
+  #       # Register version-specific models
+  #     end
+  #   end
+  #
+  module Versioned
+    # @api public
+    # Called when a module extends Versioned
+    def self.extended(base)
+      base.class_eval do
+        @version_register = nil
+        @initialized = false
+      end
+    end
+
+    # @api public
+    # Get the register for this version
+    #
+    # @return [Lutaml::Model::Register] The version-specific register
+    def register
+      @register ||= create_register
+    end
+
+    # @api public
+    # Create and configure the register
+    #
+    # @return [Lutaml::Model::Register]
+    def create_register
+      reg = Lutaml::Model::Register.new(register_id, fallback: fallback_registers)
+
+      # Register in GlobalRegister first
+      Lutaml::Model::GlobalRegister.register(reg)
+
+      # Bind to all namespaces this version handles
+      namespace_classes.each do |ns_class|
+        reg.bind_namespace(ns_class)
+      end
+
+      @version_register = reg
+    end
+
+    # @api public
+    # Initialize this version's model tree
+    #
+    # This should be called after all version-specific models are defined.
+    # It registers all models in this version's register.
+    #
+    # @return [void]
+    def init_models!
+      return if @initialized
+
+      register
+      register_models!
+
+      @initialized = true
+    end
+
+    # @api public
+    # Register all models for this version
+    #
+    # Override in each version module to register specific models.
+    #
+    # @return [void]
+    def register_models!
+      raise NotImplementedError,
+            "Each version must implement #register_models!"
+    end
+
+    # @api public
+    # Get the register ID for this version
+    #
+    # @return [Symbol]
+    def register_id
+      raise NotImplementedError,
+            "Each version must implement #register_id"
+    end
+
+    # @api public
+    # Get namespace classes this version binds to
+    #
+    # @return [Array<Class>] Array of Lutaml::Xml::Namespace subclasses
+    def namespace_classes
+      raise NotImplementedError,
+            "Each version must implement #namespace_classes"
+    end
+
+    # @api public
+    # Get fallback register IDs for this version
+    #
+    # Default: fall back to common, then default.
+    # Override for version chains (e.g., V20161101 falls back to V20131001).
+    #
+    # @return [Array<Symbol>]
+    def fallback_registers
+      %i[xmi_common default]
+    end
+
+    # @api public
+    # Get the XMI namespace class for this version
+    #
+    # @return [Class, nil]
+    def xmi_namespace
+      namespace_classes.find { |ns| ns.uri.include?("/XMI/") }
+    end
+
+    # @api public
+    # Get the UML namespace class for this version
+    #
+    # @return [Class, nil]
+    def uml_namespace
+      namespace_classes.find { |ns| ns.uri.include?("/UML/") && !ns.uri.include?("UMLD") }
+    end
+
+    # @api public
+    # Check if this version has been initialized
+    #
+    # @return [Boolean]
+    def initialized?
+      @initialized
+    end
+  end
+end

data/lib/xmi.rb

@@ -1,15 +1,10 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require "lutaml/model/xml_adapter/nokogiri_adapter"
-# require "lutaml/model/json_adapter/standard_json_adapter"
-# require "lutaml/model/yaml_adapter/standard_yaml_adapter"
-
-Lutaml::Model::Config.configure do |config|
-  config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
-  # config.yaml_adapter = Lutaml::Model::YamlAdapter::StandardYamlAdapter
-  # config.json_adapter = Lutaml::Model::JsonAdapter::StandardJsonAdapter
-end
+require "lutaml/xml"
+
+# Configure XML adapter
+Lutaml::Model::Config.xml_adapter_type = :nokogiri
 
 module Lutaml
   module Model
@@ -22,12 +17,33 @@ module Lutaml
 end
 
 require_relative "xmi/version"
+require_relative "xmi/namespace"
+require_relative "xmi/namespace/dynamic"
+require_relative "xmi/type"
+require_relative "xmi/namespace_detector"
+require_relative "xmi/namespace_registry"
 
 module Xmi
   class Error < StandardError; end
-  # Your code goes here...
+
+  # Shared value_map for XMI elements
+  # Used to handle nil, empty, and omitted values consistently
+  VALUE_MAP = {
+    from: { nil: :empty, empty: :empty, omitted: :empty },
+    to: { nil: :empty, empty: :empty, omitted: :empty },
+  }.freeze
 end
 
+# Bootstrap the namespace registry
+Xmi::NamespaceRegistry.bootstrap!
+
+# Version infrastructure
+require_relative "xmi/versioned"
+require_relative "xmi/version_registry"
+require_relative "xmi/v20110701"
+require_relative "xmi/v20131001"
+require_relative "xmi/v20161101"
+
 require_relative "xmi/add"
 require_relative "xmi/delete"
 require_relative "xmi/difference"
@@ -36,6 +52,62 @@ require_relative "xmi/extension"
 require_relative "xmi/replace"
 require_relative "xmi/ea_root"
 require_relative "xmi/uml"
-require_relative "xmi/the_custom_profile"
+require_relative "xmi/custom_profile"
 require_relative "xmi/root"
 require_relative "xmi/sparx"
+
+# Unified parsing API
+require_relative "xmi/parsing"
+
+module Xmi
+  class << self
+    # @api public
+    # Initialize all version registers
+    #
+    # Call this during gem initialization or before first use.
+    #
+    # @return [void]
+    def init_versioning!
+      return if @versioning_initialized
+
+      # Initialize versions in order (newest depends on older)
+      V20110701.init_models!
+      V20131001.init_models!
+      V20161101.init_models!
+
+      @versioning_initialized = true
+    end
+
+    # @api public
+    # Parse XMI with automatic version detection
+    #
+    # @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)
+    end
+
+    # @api public
+    # Parse XMI with a specific version register
+    #
+    # @param xml_content [String] XML content
+    # @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)
+    end
+
+    # @api public
+    # Check if versioning has been initialized
+    #
+    # @return [Boolean]
+    def versioning_initialized?
+      @versioning_initialized || false
+    end
+  end
+end