xmi 0.3.21 → 0.5.0

data/lib/xmi/namespace_detector.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Xmi
+  # Detects namespace versions from XMI XML content
+  #
+  # This class parses XMI files to extract namespace URIs and detect
+  # the specific versions of XMI, UML, and other OMG specifications used.
+  class NamespaceDetector
+    VERSION_PATTERN = /(\d{8})/
+
+    # Namespace URI patterns for OMG specifications
+    NS_PATTERNS = {
+      xmi: %r{http://www\.omg\.org/spec/XMI/(\d{8})},
+      uml: %r{http://www\.omg\.org/spec/UML/(\d{8})},
+      umldi: %r{http://www\.omg\.org/spec/UML/(\d{8})/UMLDI},
+      umldc: %r{http://www\.omg\.org/spec/UML/(\d{8})/UMLDC},
+    }.freeze
+
+    # Detect all namespace versions from XML content
+    #
+    # @param xml_content [String] The XML content to parse
+    # @return [Hash] A hash with namespace types as keys and version strings as values
+    #   Example: { xmi: "20131001", uml: "20131001", umldi: nil, umldc: nil }
+    def self.detect_versions(xml_content)
+      namespaces = extract_namespace_uris(xml_content)
+      {
+        xmi: detect_version(namespaces, :xmi),
+        uml: detect_version(namespaces, :uml),
+        umldi: detect_version(namespaces, :umldi),
+        umldc: detect_version(namespaces, :umldc),
+      }
+    end
+
+    # Extract all namespace URIs from XML content
+    #
+    # @param xml_content [String] The XML content to parse
+    # @return [Hash<String, String>] A hash mapping prefixes to namespace URIs
+    def self.extract_namespace_uris(xml_content)
+      doc = Nokogiri::XML(xml_content, &:noent)
+      doc.collect_namespaces
+    rescue Nokogiri::XML::SyntaxError
+      {}
+    end
+
+    # Detect version for a specific namespace type
+    #
+    # @param namespaces [Hash<String, String>] The namespace URIs hash
+    # @param type [Symbol] The namespace type (:xmi, :uml, :umldi, :umldc)
+    # @return [String, nil] The version string (e.g., "20131001") or nil if not found
+    def self.detect_version(namespaces, type)
+      pattern = NS_PATTERNS[type]
+      return nil unless pattern
+
+      namespaces.each_value do |uri|
+        match = uri.match(pattern)
+        return match[1] if match
+      end
+
+      nil
+    end
+
+    # Get the full namespace URI for a detected version
+    #
+    # @param type [Symbol] The namespace type (:xmi, :uml, etc.)
+    # @param version [String] The version string (e.g., "20131001")
+    # @return [String, nil] The full namespace URI
+    def self.build_namespace_uri(type, version)
+      case type
+      when :xmi
+        "http://www.omg.org/spec/XMI/#{version}"
+      when :uml
+        "http://www.omg.org/spec/UML/#{version}"
+      when :umldi
+        "http://www.omg.org/spec/UML/#{version}/UMLDI"
+      when :umldc
+        "http://www.omg.org/spec/UML/#{version}/UMLDC"
+      end
+    end
+
+    # Get detected namespace URIs for all detected versions
+    #
+    # @param xml_content [String] The XML content to parse
+    # @return [Hash] A hash with namespace types as keys and URIs as values
+    def self.detect_namespace_uris(xml_content)
+      versions = detect_versions(xml_content)
+      {
+        xmi: versions[:xmi] ? build_namespace_uri(:xmi, versions[:xmi]) : nil,
+        uml: versions[:uml] ? build_namespace_uri(:uml, versions[:uml]) : nil,
+        umldi: if versions[:umldi]
+                 build_namespace_uri(:umldi,
+                                     versions[:umldi])
+               end,
+        umldc: if versions[:umldc]
+                 build_namespace_uri(:umldc,
+                                     versions[:umldc])
+               end,
+      }
+    end
+
+    # Check if the XML uses a specific namespace version
+    #
+    # @param xml_content [String] The XML content to check
+    # @param type [Symbol] The namespace type
+    # @param version [String] The version to check for
+    # @return [Boolean] True if the XML uses the specified version
+    def self.uses_version?(xml_content, type, version)
+      detected = detect_versions(xml_content)
+      detected[type] == version
+    end
+
+    # Get a summary of all namespaces and their versions in the XML
+    #
+    # @param xml_content [String] The XML content to analyze
+    # @return [Hash] Detailed namespace information
+    def self.analyze(xml_content)
+      versions = detect_versions(xml_content)
+      uris = detect_namespace_uris(xml_content)
+      raw_namespaces = extract_namespace_uris(xml_content)
+
+      {
+        versions: versions,
+        uris: uris,
+        raw_namespaces: raw_namespaces,
+        normalized_needed: normalization_needed?(versions),
+      }
+    end
+
+    # Check if namespace normalization is needed
+    #
+    # @param versions [Hash] The detected versions hash
+    # @return [Boolean] True if any namespace is not 20131001
+    def self.normalization_needed?(versions)
+      versions.values.any? { |v| v && v != "20131001" }
+    end
+  end
+end

data/lib/xmi/namespace_registry.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Xmi
+  # Registry for mapping namespace URIs to namespace classes
+  #
+  # This module provides a central registry for namespace classes,
+  # allowing dynamic lookup of namespace classes by URI.
+  module NamespaceRegistry
+    class << self
+      # Get the URI-to-class mapping
+      #
+      # @return [Hash<String, Class>] The mapping of URIs to namespace classes
+      def uri_map
+        @uri_map ||= {}
+      end
+
+      # Register a URI-to-class mapping
+      #
+      # @param uri [String] The namespace URI
+      # @param namespace_class [Class] The namespace class
+      def register(uri, namespace_class)
+        uri_map[uri] = namespace_class
+      end
+
+      # Resolve a namespace class by URI
+      #
+      # @param uri [String] The namespace URI to look up
+      # @return [Class, nil] The namespace class or nil if not found
+      def resolve(uri)
+        uri_map[uri]
+      end
+
+      # Check if a URI is registered
+      #
+      # @param uri [String] The namespace URI to check
+      # @return [Boolean] True if the URI is registered
+      def registered?(uri)
+        uri_map.key?(uri)
+      end
+
+      # Get all registered URIs
+      #
+      # @return [Array<String>] List of registered URIs
+      def registered_uris
+        uri_map.keys
+      end
+
+      # Clear the registry (mainly for testing)
+      def clear
+        @uri_map = {}
+      end
+
+      # Bootstrap the registry with all known OMG and Sparx namespaces
+      #
+      # This method registers all known namespace URIs from the
+      # Xmi::Namespace::Omg and Xmi::Namespace::Sparx modules.
+      def bootstrap!
+        register_omg_namespaces!
+        register_sparx_namespaces!
+      end
+
+      private
+
+      # Register all OMG namespace URIs
+      def register_omg_namespaces!
+        return unless defined?(::Xmi::Namespace::Omg)
+
+        # XMI namespaces
+        register("http://www.omg.org/spec/XMI/20110701",
+                 ::Xmi::Namespace::Omg::Xmi20110701)
+        register("http://www.omg.org/spec/XMI/20131001",
+                 ::Xmi::Namespace::Omg::Xmi20131001)
+        register("http://www.omg.org/spec/XMI/20161101",
+                 ::Xmi::Namespace::Omg::Xmi20161101)
+
+        # UML namespaces
+        register("http://www.omg.org/spec/UML/20110701",
+                 ::Xmi::Namespace::Omg::Uml20110701)
+        register("http://www.omg.org/spec/UML/20131001",
+                 ::Xmi::Namespace::Omg::Uml20131001)
+        register("http://www.omg.org/spec/UML/20161101",
+                 ::Xmi::Namespace::Omg::Uml20161101)
+
+        # UMLDI namespaces
+        register("http://www.omg.org/spec/UML/20131001/UMLDI",
+                 ::Xmi::Namespace::Omg::UmlDi20131001)
+        register("http://www.omg.org/spec/UML/20161101/UMLDI",
+                 ::Xmi::Namespace::Omg::UmlDi20161101)
+
+        # UMLDC namespaces
+        register("http://www.omg.org/spec/UML/20131001/UMLDC",
+                 ::Xmi::Namespace::Omg::UmlDc20131001)
+        register("http://www.omg.org/spec/UML/20161101/UMLDC",
+                 ::Xmi::Namespace::Omg::UmlDc20161101)
+      end
+
+      # Register all Sparx namespace URIs
+      def register_sparx_namespaces!
+        return unless defined?(::Xmi::Namespace::Sparx)
+
+        # Sparx profile namespaces
+        register("http://www.sparxsystems.com/profiles/SysPhS/1.0",
+                 ::Xmi::Namespace::Sparx::SysPhS)
+        register("http://www.sparxsystems.com/profiles/GML/1.0",
+                 ::Xmi::Namespace::Sparx::Gml)
+        register("http://www.sparxsystems.com/profiles/EAUML/1.0",
+                 ::Xmi::Namespace::Sparx::EaUml)
+        register("http://www.sparxsystems.com/profiles/thecustomprofile/1.0",
+                 ::Xmi::Namespace::Sparx::CustomProfile)
+        register("http://www.sparxsystems.com/profiles/CityGML/1.0",
+                 ::Xmi::Namespace::Sparx::CityGml)
+
+        # Sparx Extension namespace (for EA-specific elements)
+        register("http://www.sparxsystems.com/extensions/ea",
+                 ::Xmi::Namespace::Sparx::Extension)
+      end
+    end
+  end
+end

data/lib/xmi/parsing.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Xmi
+  # Unified API for XMI parsing with version support
+  #
+  # This module provides a consistent interface for parsing XMI documents
+  # with automatic version detection or explicit version specification.
+  #
+  # @example
+  #   # Auto-detect version from XML
+  #   doc = Xmi::Parsing.parse(xml_content)
+  #
+  # @example
+  #   # Force specific version
+  #   doc = Xmi::Parsing.parse(xml_content, version: "20131001")
+  #
+  module Parsing
+    class << self
+      # @api public
+      # Parse XMI with automatic version detection
+      #
+      # @param xml [String, IO] XML content or stream
+      # @param options [Hash] Parsing options
+      # @option options [String] :version Force specific version
+      # @option options [Lutaml::Model::Register] :register Use specific register
+      # @option options [Class] :model_class Model class to parse into
+      # @option options [Boolean] :strict Raise on unknown elements
+      # @return [Root, Object] Parsed XMI document
+      def parse(xml, options = {})
+        xml_content = xml.respond_to?(:read) ? xml.read : xml.to_s
+
+        Xmi.init_versioning! unless Xmi.versioning_initialized?
+
+        register = determine_register(xml_content, options)
+        model_class = options[:model_class] || Root
+
+        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
+
+      # @api public
+      # Parse XMI file
+      #
+      # @param path [String] File path
+      # @param options [Hash] Parsing options
+      # @return [Root, Object] Parsed XMI document
+      def parse_file(path, options = {})
+        parse(File.read(path), options)
+      end
+
+      # @api public
+      # Detect XMI version without full parsing
+      #
+      # @param xml [String] XML content
+      # @return [Hash] Version information with :versions and :uris keys
+      def detect_version(xml)
+        versions = NamespaceDetector.detect_versions(xml)
+        uris = NamespaceDetector.detect_namespace_uris(xml)
+
+        {
+          versions: versions,
+          uris: uris,
+          xmi_version: versions[:xmi],
+          uml_version: versions[:uml],
+        }
+      end
+
+      # @api public
+      # Get supported XMI versions
+      #
+      # @return [Array<String>]
+      def supported_versions
+        VersionRegistry.available_versions
+      end
+
+      # @api public
+      # Check if a version is supported
+      #
+      # @param version [String] Version string (e.g., "20131001")
+      # @return [Boolean]
+      def version_supported?(version)
+        supported_versions.include?(version)
+      end
+
+      private
+
+      # Determine the appropriate register for parsing
+      #
+      # @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
+        return options[:register] if options[:register]
+
+        # Explicit version
+        if options[:version]
+          reg = VersionRegistry.register_for_version(options[:version])
+          raise ArgumentError, "Unknown version: #{options[:version]}" unless reg
+
+          return reg
+        end
+
+        # Auto-detect from XML content
+        VersionRegistry.detect_register(xml_content)
+      end
+    end
+  end
+end

data/lib/xmi/replace.rb

@@ -5,12 +5,12 @@ require_relative "extension"
 
 module Xmi
   class Replace < Lutaml::Model::Serializable
-    attribute :id, :string
-    attribute :label, :string
-    attribute :uuid, :string
+    attribute :id, ::Xmi::Type::XmiId
+    attribute :label, ::Xmi::Type::XmiLabel
+    attribute :uuid, ::Xmi::Type::XmiUuid
     attribute :href, :string
-    attribute :idref, :string
-    attribute :type, :string
+    attribute :idref, ::Xmi::Type::XmiIdRef
+    attribute :type, ::Xmi::Type::XmiType
     attribute :target, :string
     attribute :container, :string
     attribute :position, :integer
@@ -18,46 +18,22 @@ module Xmi
     attribute :difference, Difference, collection: true
     attribute :extension, Extension, collection: true
 
-    xml do # rubocop:disable Metrics/BlockLength
+    xml do
       root "Replace"
-      namespace "http://www.omg.org/spec/XMI/20131001", "xmlns"
+      namespace ::Xmi::Namespace::Omg::Xmi
 
-      map_attribute "id", to: :id, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "label", to: :label, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "uuid", to: :uuid, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
+      map_attribute "id", to: :id
+      map_attribute "label", to: :label
+      map_attribute "uuid", to: :uuid
       map_attribute "href", to: :href
-      map_attribute "idref", to: :idref, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "type", to: :type, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
+      map_attribute "idref", to: :idref
+      map_attribute "type", to: :type
       map_attribute "target", to: :target
       map_attribute "container", to: :container
       map_attribute "position", to: :position
       map_attribute "replacement", to: :replacement
-      map_element "difference", to: :difference, prefix: nil, namespace: nil,
-                                value_map: {
-                                  from: {
-                                    nil: :empty,
-                                    empty: :empty,
-                                    omitted: :empty
-                                  },
-                                  to: {
-                                    nil: :empty,
-                                    empty: :empty,
-                                    omitted: :empty
-                                  }
-                                }
-      map_element "Extension", to: :extension,
-                               value_map: {
-                                 from: {
-                                   nil: :empty,
-                                   empty: :empty,
-                                   omitted: :empty
-                                 },
-                                 to: {
-                                   nil: :empty,
-                                   empty: :empty,
-                                   omitted: :empty
-                                 }
-                               }
+      map_element "difference", to: :difference, value_map: VALUE_MAP
+      map_element "Extension", to: :extension, value_map: VALUE_MAP
     end
   end
 end