xmi 0.3.21 → 0.5.0

data/lib/xmi/documentation.rb

@@ -3,13 +3,13 @@
 require_relative "extension"
 
 module Xmi
-  class Documentation < Lutaml::Model::Serializable # rubocop:disable Metrics/ClassLength
-    attribute :id, :string
-    attribute :label, :string
-    attribute :uuid, :string
+  class Documentation < Lutaml::Model::Serializable
+    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 :contact, :string, collection: true
     attribute :exporter, :string
     attribute :exporter_version, :string
@@ -21,9 +21,9 @@ module Xmi
     attribute :timestamp, :time, collection: true
     attribute :extension, Extension, collection: true
 
-    xml do # rubocop:disable Metrics/BlockLength
+    xml do
       root "Documentation"
-      namespace "http://www.omg.org/spec/XMI/20131001", "xmi"
+      namespace ::Xmi::Namespace::Omg::Xmi
 
       map_attribute "id", to: :id
       map_attribute "label", to: :label
@@ -35,99 +35,14 @@ module Xmi
       map_attribute "exporterVersion", to: :exporter_version
       map_attribute "exporterID", to: :exporter_id
 
-      map_element "contact", to: :contact, prefix: nil, namespace: nil,
-                             value_map: {
-                               from: {
-                                 nil: :empty,
-                                 empty: :empty,
-                                 omitted: :empty
-                               },
-                               to: {
-                                 nil: :empty,
-                                 empty: :empty,
-                                 omitted: :empty
-                               }
-                             }
-      map_element "longDescription", to: :long_description, prefix: nil,
-                                     namespace: nil,
-                                     value_map: {
-                                       from: {
-                                         nil: :empty,
-                                         empty: :empty,
-                                         omitted: :empty
-                                       },
-                                       to: {
-                                         nil: :empty,
-                                         empty: :empty,
-                                         omitted: :empty
-                                       }
-                                     }
-      map_element "shortDescription", to: :short_description, prefix: nil,
-                                      namespace: nil,
-                                      value_map: {
-                                        from: {
-                                          nil: :empty,
-                                          empty: :empty,
-                                          omitted: :empty
-                                        },
-                                        to: {
-                                          nil: :empty,
-                                          empty: :empty,
-                                          omitted: :empty
-                                        }
-                                      }
-      map_element "notice", to: :notice, prefix: nil, namespace: nil,
-                            value_map: {
-                              from: {
-                                nil: :empty,
-                                empty: :empty,
-                                omitted: :empty
-                              },
-                              to: {
-                                nil: :empty,
-                                empty: :empty,
-                                omitted: :empty
-                              }
-                            }
-      map_element "owner", to: :owner, prefix: nil, namespace: nil,
-                           value_map: {
-                             from: {
-                               nil: :empty,
-                               empty: :empty,
-                               omitted: :empty
-                             },
-                             to: {
-                               nil: :empty,
-                               empty: :empty,
-                               omitted: :empty
-                             }
-                           }
-      map_element "timestamp", to: :timestamp, 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 "contact", to: :contact, value_map: VALUE_MAP
+      map_element "longDescription", to: :long_description, value_map: VALUE_MAP
+      map_element "shortDescription", to: :short_description,
+                                      value_map: VALUE_MAP
+      map_element "notice", to: :notice, value_map: VALUE_MAP
+      map_element "owner", to: :owner, value_map: VALUE_MAP
+      map_element "timestamp", to: :timestamp, value_map: VALUE_MAP
+      map_element "Extension", to: :extension, value_map: VALUE_MAP
     end
   end
 end

data/lib/xmi/ea_root.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-Dir[File.join(__dir__, "extensions", "*.rb")].each { |file| require file }
-
 require "nokogiri"
 
 module Xmi
@@ -27,6 +25,7 @@ module Xmi
     XML_MAPPING = <<~TEXT
               xml do
                 root "#ROOT_TAG#"
+                namespace #NAMESPACE_CLASS#
       #MAP_ATTRIBUTES#
               end
     TEXT
@@ -42,23 +41,64 @@ module Xmi
     MAP_ELEMENT = <<~TEXT
       map_element "#ELEMENT_NAME#",
                   to: :#ELEMENT_METHOD#,
-                  namespace: "#NAMESPACE#",
-                  prefix: "#PREFIX#",
-                  value_map: {
-                    from: { nil: :empty, empty: :empty, omitted: :empty },
-                    to: { nil: :empty, empty: :empty, omitted: :empty }
-                  }
+                  value_map: Xmi::VALUE_MAP
     TEXT
 
     class << self
+      # Load an EA extension from an XML file.
+      #
+      # @param xml_path [String] Path to the MDG extension XML file
+      # @return [void]
+      # @raise [ArgumentError] If the extension is already loaded
       def load_extension(xml_path)
         @content = gen_content(xml_path)
+        extension_id = @module_name
+
+        if loaded_extensions.key?(extension_id)
+          raise ArgumentError,
+                "Extension '#{extension_id}' is already loaded from " \
+                "'#{loaded_extensions[extension_id]}'. " \
+                "Call unload_extension('#{extension_id}') first if you want to reload it."
+        end
+
         Object.class_eval @content
-        update_mappings(@module_name)
+        update_mappings(extension_id)
+        loaded_extensions[extension_id] = xml_path
+      end
+
+      # Unload an extension by removing its module and clearing tracking.
+      #
+      # This allows the extension to be loaded again, which is useful for
+      # testing scenarios that need to reload extensions.
+      #
+      # @param extension_id [String, Symbol] The extension module name (e.g., "Citygml")
+      # @return [void]
+      def unload_extension(extension_id)
+        extension_id = extension_id.to_s.capitalize
+
+        remove_const(extension_id) if const_defined?(extension_id)
+
+        loaded_extensions.delete(extension_id)
+      end
+
+      # Check if an extension is currently loaded.
+      #
+      # @param extension_id [String, Symbol] The extension module name
+      # @return [Boolean]
+      def extension_loaded?(extension_id)
+        extension_id = extension_id.to_s.capitalize
+        loaded_extensions.key?(extension_id)
+      end
+
+      # List all currently loaded extensions.
+      #
+      # @return [Hash<String, String>] Map of extension_id => xml_path
+      def loaded_extensions
+        @loaded_extensions ||= {}
       end
 
       def output_rb_file(output_rb_path)
-        File.open(output_rb_path, "w") { |file| file.write(@content) }
+        File.write(output_rb_path, @content)
       end
 
       private
@@ -70,17 +110,17 @@ module Xmi
         update_model_xml_mappings(map_elements, Xmi::Sparx::SparxRoot)
       end
 
-      def construct_xml_mappings(new_klasses, module_name) # rubocop:disable Metrics/MethodLength
+      def construct_xml_mappings(new_klasses, module_name)
         map_elements = []
         new_klasses.each do |klass|
           next unless Xmi::EaRoot.const_get(module_name).const_get(klass)
-                                 .respond_to? :root_tag
+            .respond_to? :root_tag
 
           map_elements << MAP_ELEMENT
-                          .gsub("#ELEMENT_NAME#", Xmi::EaRoot.const_get(module_name).const_get(klass).root_tag)
-                          .gsub("#ELEMENT_METHOD#", Lutaml::Model::Utils.snake_case(klass.to_s))
-                          .gsub("#NAMESPACE#", @def_namespace[:uri])
-                          .gsub("#PREFIX#", @def_namespace[:name])
+            .gsub("#ELEMENT_NAME#", Xmi::EaRoot.const_get(module_name).const_get(klass).root_tag)
+            .gsub("#ELEMENT_METHOD#", Lutaml::Model::Utils.snake_case(klass.to_s))
+            .gsub("#NAMESPACE#", @def_namespace[:uri])
+            .gsub("#PREFIX#", @def_namespace[:name])
         end
 
         map_elements
@@ -92,23 +132,29 @@ module Xmi
           full_klass_name = "Xmi::EaRoot::#{module_name}::#{klass}"
           attr_line = "#{ATTRIBUTE_LINE.rstrip}, collection: true"
           attr_line = attr_line
-                      .gsub("#TAG_NAME#", method_name)
-                      .gsub("#ATTRIBUTE_TYPE#", full_klass_name)
+            .gsub("#TAG_NAME#", method_name)
+            .gsub("#ATTRIBUTE_TYPE#", full_klass_name)
 
           sparx_root.class_eval(attr_line)
         end
       end
 
+      # Add extension element mappings to SparxRoot.
+      #
+      # Only adds NEW mappings for the extension elements. Does NOT re-evaluate
+      # the base mappings, which avoids duplicate mapping accumulation.
+      #
+      # @param map_elements [Array<String>] Array of map_element code strings
+      # @param sparx_root [Class] The SparxRoot class to update
       def update_model_xml_mappings(map_elements, sparx_root)
-        new_mapping = sparx_root.class_variable_get("@@default_mapping")
-        new_mapping += map_elements.join("\n")
-        sparx_root.class_variable_set("@@mapping", new_mapping) # rubocop:disable Style/ClassVars
+        return if map_elements.empty?
 
-        new_mapping_block = proc do
-          eval sparx_root.class_variable_get("@@mapping") # rubocop:disable Security/Eval
+        # Only add the NEW extension element mappings.
+        # Do NOT re-evaluate base mappings to avoid duplicates.
+        extension_block = proc do
+          map_elements.each { |element_code| instance_eval(element_code) }
         end
-        new_mapping = proc { xml(&new_mapping_block) }
-        sparx_root.class_eval(&new_mapping)
+        sparx_root.class_eval { xml(&extension_block) }
       end
 
       def all_new_klasses(module_name)
@@ -119,7 +165,7 @@ module Xmi
 
       def get_abstract_klass_node(xmi_doc)
         xmi_doc.at_xpath(
-          "//UMLProfiles//Stereotypes//Stereotype[@isAbstract='true']"
+          "//UMLProfiles//Stereotypes//Stereotype[@isAbstract='true']",
         )
       end
 
@@ -134,8 +180,8 @@ module Xmi
         method_name = Lutaml::Model::Utils.snake_case(attr_method)
 
         map_attributes = MAP_ATTRIBUTES
-                         .gsub("#ATTRIBUTE_NAME#", attr_name)
-                         .gsub("#ATTRIBUTE_METHOD#", method_name)
+          .gsub("#ATTRIBUTE_NAME#", attr_name)
+          .gsub("#ATTRIBUTE_METHOD#", method_name)
 
         "#{space_before}#{map_attributes}"
       end
@@ -145,8 +191,8 @@ module Xmi
         space_before = " " * 8
 
         attribute_line = ATTRIBUTE_LINE
-                         .gsub("#TAG_NAME#", tag_name)
-                         .gsub("#ATTRIBUTE_TYPE#", attribute_type)
+          .gsub("#TAG_NAME#", tag_name)
+          .gsub("#ATTRIBUTE_TYPE#", attribute_type)
 
         "#{space_before}#{attribute_line}"
       end
@@ -168,7 +214,7 @@ module Xmi
         [attributes_lines, tags]
       end
 
-      def gen_abstract_klass # rubocop:disable Metrics/MethodLength
+      def gen_abstract_klass
         unless @abstract_klass_node
           @abstract_tags = []
           return ""
@@ -201,7 +247,7 @@ module Xmi
         [apply_types_lines, apply_types_nodes]
       end
 
-      def gen_generic_klass(node, from_klass = nil) # rubocop:disable Metrics/MethodLength
+      def gen_generic_klass(node, from_klass = nil)
         node_name = get_klass_name_from_node(node)
         attributes_lines, map_attributes_lines = gen_klass_tags(node)
         apply_types_lines, apply_types_nodes = gen_apply_types(node)
@@ -229,7 +275,8 @@ module Xmi
         map_attributes_lines
       end
 
-      def gen_klass_apply_types(attributes_lines, map_attributes_lines, apply_types_lines, apply_types_nodes) # rubocop:disable Metrics/MethodLength
+      def gen_klass_apply_types(attributes_lines, map_attributes_lines,
+apply_types_lines, apply_types_nodes)
         unless apply_types_nodes.empty?
           attributes_lines += apply_types_lines
           apply_types_nodes.each do |n|
@@ -260,12 +307,46 @@ module Xmi
       end
 
       def replace_xml_mapping(node_name, map_attributes_lines)
+        # Look up namespace class by URI, or generate a new one if not found
+        ns_class = find_or_create_namespace_class
+
         XML_MAPPING
           .gsub("#ROOT_TAG#", node_name)
+          .gsub("#NAMESPACE_CLASS#", ns_class)
           .gsub("#MAP_ATTRIBUTES#", "\n#{map_attributes_lines.rstrip}")
           .rstrip
       end
 
+      def find_or_create_namespace_class
+        uri = @def_namespace[:uri]
+        prefix = @def_namespace[:name]
+
+        # Try to find existing namespace class in registry
+        existing_class = NamespaceRegistry.resolve(uri)
+        return existing_class.name if existing_class
+
+        # Generate a new namespace class
+        # Format: Xmi::Namespace::Dynamic::{ModuleName}
+        module_name = @module_name
+        ns_class_name = "Xmi::Namespace::Dynamic::#{module_name}"
+
+        # Check if already defined
+        return ns_class_name if Object.const_defined?(ns_class_name)
+
+        # Create the namespace class
+        Namespace.ensure_dynamic_namespace_module_exists!
+        ns_class = Class.new(Lutaml::Xml::Namespace) do
+          define_singleton_method(:uri) { uri }
+          define_singleton_method(:prefix_default) { prefix }
+        end
+        Namespace::Dynamic.const_set(module_name, ns_class)
+
+        # Register in namespace registry
+        NamespaceRegistry.register(uri, ns_class)
+
+        ns_class_name
+      end
+
       def replace_klass_template(node_name, attributes_lines, xml_mapping,
                                  from_klass = nil)
         abstract_klass_name = get_klass_name_from_node(@abstract_klass_node)

data/lib/xmi/extension.rb

@@ -2,18 +2,18 @@
 
 module Xmi
   class Extension < 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 :extender, :string
     attribute :extender_id, :string
 
     xml do
       root "Extension"
-      namespace "http://www.omg.org/spec/XMI/20131001", "xmi"
+      namespace ::Xmi::Namespace::Omg::Xmi
 
       map_attribute "id", to: :id
       map_attribute "label", to: :label

data/lib/xmi/namespace/dynamic.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Namespace
+    # Module for dynamically created namespace classes
+    # These are created when loading EA MDG extensions
+    module Dynamic
+      class << self
+        # Ensure the Dynamic namespace module exists
+        # This is a no-op since the module is already defined
+        def ensure_exists!
+          # Already defined by Ruby when this file is loaded
+        end
+      end
+    end
+  end
+end
+
+# Add convenience method to parent module
+module Xmi
+  module Namespace
+    class << self
+      def ensure_dynamic_namespace_module_exists!
+        Dynamic.ensure_exists!
+      end
+    end
+  end
+end

data/lib/xmi/namespace/omg.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Namespace
+    module Omg
+      class Xmi20110701 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/XMI/20110701"
+        prefix_default "xmi"
+      end
+
+      class Xmi20131001 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/XMI/20131001"
+        prefix_default "xmi"
+      end
+
+      class Xmi20161101 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/XMI/20161101"
+        prefix_default "xmi"
+      end
+
+      class Uml20110701 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20110701"
+        prefix_default "uml"
+      end
+
+      class Uml20131001 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20131001"
+        prefix_default "uml"
+      end
+
+      class Uml20161101 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20161101"
+        prefix_default "uml"
+      end
+
+      class UmlDi20131001 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20131001/UMLDI"
+        prefix_default "umldi"
+      end
+
+      class UmlDi20161101 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20161101/UMLDI"
+        prefix_default "umldi"
+      end
+
+      class UmlDc20131001 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20131001/UMLDC"
+        prefix_default "dc"
+      end
+
+      class UmlDc20161101 < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20161101/UMLDC"
+        prefix_default "dc"
+      end
+
+      # Alias classes for version-agnostic reference
+      # These inherit from 20131001 (the normalized version used after replace_xmlns)
+      # NOTE: We need to explicitly set uri and prefix_default because Ruby class
+      # instance variables are not inherited
+      class Xmi < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/XMI/20131001"
+        prefix_default "xmi"
+      end
+
+      class Uml < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20131001"
+        prefix_default "uml"
+      end
+
+      class UmlDi < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20131001/UMLDI"
+        prefix_default "umldi"
+      end
+
+      class UmlDc < Lutaml::Xml::Namespace
+        uri "http://www.omg.org/spec/UML/20131001/UMLDC"
+        prefix_default "dc"
+      end
+    end
+  end
+end

data/lib/xmi/namespace/sparx.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Namespace
+    module Sparx
+      # Namespace for EA Extension elements (inside <xmi:Extension>)
+      # These are elements like <elements>, <connectors>, <diagrams>, etc.
+      class Extension < Lutaml::Xml::Namespace
+        uri "http://www.sparxsystems.com/extensions/ea"
+        prefix_default "ea"
+      end
+
+      class SysPhS < Lutaml::Xml::Namespace
+        uri "http://www.sparxsystems.com/profiles/SysPhS/1.0"
+        prefix_default "sysphs"
+      end
+
+      class Gml < Lutaml::Xml::Namespace
+        uri "http://www.sparxsystems.com/profiles/GML/1.0"
+        prefix_default "GML"
+      end
+
+      class EaUml < Lutaml::Xml::Namespace
+        uri "http://www.sparxsystems.com/profiles/EAUML/1.0"
+        prefix_default "EAUML"
+      end
+
+      class CustomProfile < Lutaml::Xml::Namespace
+        uri "http://www.sparxsystems.com/profiles/thecustomprofile/1.0"
+        prefix_default "thecustomprofile"
+      end
+
+      class CityGml < Lutaml::Xml::Namespace
+        uri "http://www.sparxsystems.com/profiles/CityGML/1.0"
+        prefix_default "CityGML"
+      end
+    end
+  end
+end

data/lib/xmi/namespace.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Namespace
+  end
+end
+
+require_relative "namespace/omg"
+require_relative "namespace/sparx"