xmi 0.5.4 → 0.5.6

data/lib/xmi/ea_root.rb

@@ -1,58 +1,25 @@
 # frozen_string_literal: true
 
 require "nokogiri"
+require_relative "ea_root/xml_parsing"
+require_relative "ea_root/code_generation"
+require_relative "ea_root/extension_lifecycle"
+require_relative "ea_root/namespace_handling"
 
 module Xmi
-  class EaRoot # rubocop:disable Metrics/ClassLength
-    MODULE_TEMPLATE = <<~TEXT
-      module Xmi
-        class EaRoot
-          module #MODULE_NAME#
-      #KLASSES#
-          end
-        end
-      end
-    TEXT
-
-    KLASS_TEMPLATE = <<~TEXT
-            class #KLASS_NAME# < #FROM_KLASS#
-              #ROOT_TAG_LINE#
-
-      #ATTRIBUTES##XML_MAPPING#
-            end
-    TEXT
+  class EaRoot
+    extend XmlParsing
+    extend CodeGeneration
+    extend ExtensionLifecycle
+    extend NamespaceHandling
 
-    XML_MAPPING = <<~TEXT
-              xml do
-                root "#ROOT_TAG#"
-                namespace #NAMESPACE_CLASS#
-      #MAP_ATTRIBUTES#
-              end
-    TEXT
-
-    ATTRIBUTE_LINE = <<~TEXT
-      attribute :#TAG_NAME#, #ATTRIBUTE_TYPE#
-    TEXT
-
-    MAP_ATTRIBUTES = <<~TEXT
-      map_attribute "#ATTRIBUTE_NAME#", to: :#ATTRIBUTE_METHOD#
-    TEXT
-
-    MAP_ELEMENT = <<~TEXT
-      map_element "#ELEMENT_NAME#",
-                  to: :#ELEMENT_METHOD#,
-                  value_map: Xmi::VALUE_MAP
-    TEXT
+    private_constant :XmlParsing, :CodeGeneration, :ExtensionLifecycle,
+                     :NamespaceHandling
 
     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
+        xmi_doc = Nokogiri::XML(File.read(xml_path))
+        extension_id = get_module_name(xmi_doc)
 
         if loaded_extensions.key?(extension_id)
           raise ArgumentError,
@@ -61,18 +28,11 @@ module Xmi
                 "Call unload_extension('#{extension_id}') first if you want to reload it."
         end
 
-        Object.class_eval @content
+        build_extension(xmi_doc)
         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
 
@@ -81,367 +41,14 @@ module Xmi
         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.write(output_rb_path, @content)
-      end
-
-      private
-
-      def update_mappings(module_name)
-        new_klasses = all_new_klasses(module_name)
-        map_elements = construct_xml_mappings(new_klasses, module_name)
-        update_model_attributes(new_klasses, Xmi::Sparx::SparxRoot, module_name)
-        update_model_xml_mappings(map_elements, Xmi::Sparx::SparxRoot)
-      end
-
-      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
-
-          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])
-        end
-
-        map_elements
-      end
-
-      def update_model_attributes(new_klasses, sparx_root, module_name)
-        new_klasses.each do |klass|
-          method_name = Lutaml::Model::Utils.snake_case(klass)
-          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)
-
-          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)
-        return if map_elements.empty?
-
-        # 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
-        sparx_root.class_eval { xml(&extension_block) }
-      end
-
-      def all_new_klasses(module_name)
-        Xmi::EaRoot.const_get(module_name).constants.select do |c|
-          Xmi::EaRoot.const_get(module_name).const_get(c).is_a? Class
-        end
-      end
-
-      def get_abstract_klass_node(xmi_doc)
-        xmi_doc.at_xpath(
-          "//UMLProfiles//Stereotypes//Stereotype[@isAbstract='true']",
-        )
-      end
-
-      def get_klass_name_from_node(node)
-        return Lutaml::Model::Serializable.to_s unless node
-
-        node.attribute_nodes.find { |attr| attr.name == "name" }.value
-      end
-
-      def gen_map_attribute_line(attr_name, attr_method)
-        space_before = " " * 10
-        method_name = Lutaml::Model::Utils.snake_case(attr_method)
-
-        map_attributes = MAP_ATTRIBUTES
-          .gsub("#ATTRIBUTE_NAME#", attr_name)
-          .gsub("#ATTRIBUTE_METHOD#", method_name)
-
-        "#{space_before}#{map_attributes}"
-      end
-
-      def gen_attribute_line(tag_name, attribute_type = ":string")
-        tag_name = Lutaml::Model::Utils.snake_case(tag_name)
-        space_before = " " * 8
-
-        attribute_line = ATTRIBUTE_LINE
-          .gsub("#TAG_NAME#", tag_name)
-          .gsub("#ATTRIBUTE_TYPE#", attribute_type)
-
-        "#{space_before}#{attribute_line}"
-      end
-
-      def get_tag_name(tag)
-        tag_name = tag.attribute_nodes.find { |attr| attr.name == "name" }.value
-        tag_name == "xmlns" ? "altered_xmlns" : tag_name
-      end
-
-      def gen_tags(node)
-        tags = node.search("Tag")
-        attributes_lines = ""
-
-        tags.each do |tag|
-          tag_name = get_tag_name(tag)
-          attributes_lines += gen_attribute_line(tag_name)
-        end
-
-        [attributes_lines, tags]
-      end
-
-      def gen_abstract_klass
-        unless @abstract_klass_node
-          @abstract_tags = []
-          return ""
-        end
-
-        attributes_lines = ""
-        tags_lines, @abstract_tags = gen_tags(@abstract_klass_node)
-        attributes_lines += tags_lines
-        klass_name = get_klass_name_from_node(@abstract_klass_node)
-
-        KLASS_TEMPLATE
-          .gsub("#KLASS_NAME#", Lutaml::Model::Utils.classify(klass_name))
-          .gsub("#FROM_KLASS#", "Lutaml::Model::Serializable")
-          .gsub("#ATTRIBUTES#", attributes_lines.rstrip)
-          .gsub("#XML_MAPPING#", "")
-          .gsub("#ROOT_TAG_LINE#", "")
-      end
-
-      def gen_apply_types(node)
-        apply_types_lines = ""
-        apply_types_nodes = node.search("Apply")
-        apply_types_nodes.each do |n|
-          apply_types = n.attribute_nodes.map(&:value)
-          apply_types.each do |apply_type|
-            tag_name = "base_#{apply_type}"
-            apply_types_lines += gen_attribute_line(tag_name)
-          end
-        end
-
-        [apply_types_lines, apply_types_nodes]
-      end
-
-      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)
-        attributes_lines, map_attributes_lines = gen_klass_apply_types(
-          attributes_lines, map_attributes_lines,
-          apply_types_lines, apply_types_nodes
-        )
-
-        map_attributes_lines = node_map_attributes(node_name,
-                                                   from_klass, map_attributes_lines)
-        xml_mapping = replace_xml_mapping(node_name, map_attributes_lines)
-
-        replace_klass_template(node_name, attributes_lines,
-                               xml_mapping, from_klass)
-      end
-
-      def node_map_attributes(node_name, from_klass, map_attributes_lines)
-        if from_klass && @node_map.key?(from_klass.to_sym)
-          map_attributes_lines += @node_map[from_klass.to_sym].to_s
-        else
-          @node_map ||= {}
-          @node_map[node_name.to_sym] = map_attributes_lines
-        end
-
-        map_attributes_lines
-      end
-
-      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|
-            apply_types = n.attribute_nodes.map(&:value)
-            apply_types.each do |apply_type|
-              map_attributes_lines += gen_map_attribute_line(
-                "base_#{apply_type}", "base_#{apply_type}"
-              )
-            end
-          end
-        end
-
-        [attributes_lines, map_attributes_lines]
-      end
-
-      def gen_klass_tags(node)
-        attributes_lines = ""
-        map_attributes_lines = ""
-
-        tags_lines, tags = gen_tags(node)
-        attributes_lines += tags_lines
-        (@abstract_tags + tags).each do |tag|
-          tag_name = get_tag_name(tag)
-          map_attributes_lines += gen_map_attribute_line(tag_name, tag_name)
-        end
-
-        [attributes_lines, map_attributes_lines]
-      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)
-        abstract_klass_name = from_klass if from_klass
-        root_tag_line = "def self.root_tag = \"#{node_name}\""
-
-        KLASS_TEMPLATE
-          .gsub("#KLASS_NAME#", Lutaml::Model::Utils.classify(node_name))
-          .gsub("#FROM_KLASS#", Lutaml::Model::Utils.classify(abstract_klass_name))
-          .gsub("#ROOT_TAG_LINE#", root_tag_line)
-          .gsub("#ATTRIBUTES#", attributes_lines.rstrip)
-          .gsub("#XML_MAPPING#", "\n\n#{xml_mapping}")
-      end
-
-      def gen_generic_klasses(xmi_doc)
-        nodes = xmi_doc.xpath("//UMLProfiles//Stereotypes//Stereotype[not(contains(@isAbstract, 'true'))]")
-        klasses_lines = ""
-
-        klasses_lines += "#{gen_generic_klasses_wo_base_stereotypes(nodes)}\n"
-        klasses_lines += "#{gen_generic_klasses_w_base_stereotypes(nodes)}\n"
-
-        klasses_lines
-      end
-
-      def gen_generic_klasses_wo_base_stereotypes(nodes)
-        nodes = nodes.select { |n| n.attributes["baseStereotypes"].nil? }
-        klasses_lines = ""
-
-        nodes.each do |node|
-          klasses_lines += "#{gen_generic_klass(node)}\n"
-        end
-
-        klasses_lines
-      end
-
-      def gen_generic_klasses_w_base_stereotypes(nodes)
-        nodes = nodes.reject { |n| n.attributes["baseStereotypes"].nil? }
-        klasses_lines = ""
-
-        nodes.each do |node|
-          base_stereotypes = node.attributes["baseStereotypes"].value
-          klasses_lines += "#{gen_generic_klass(node, base_stereotypes)}\n"
-        end
-
-        klasses_lines
-      end
-
-      def gen_klasses(xmi_doc)
-        @abstract_klass_node = get_abstract_klass_node(xmi_doc)
-        klasses_lines = ""
-        klasses_lines += "#{gen_abstract_klass}\n"
-        klasses_lines += gen_generic_klasses(xmi_doc).rstrip
-        klasses_lines
-      end
-
-      def gen_module(xmi_doc, module_name)
-        MODULE_TEMPLATE
-          .gsub("#MODULE_NAME#", module_name)
-          .gsub("#KLASSES#", gen_klasses(xmi_doc))
-      end
-
-      def get_namespace_from_definition(xmi_doc)
-        namespace_key = get_module_name_from_definition(xmi_doc)
-        namespace_uri = get_module_uri(xmi_doc)
-
-        { name: namespace_key, uri: namespace_uri }
-      end
-
-      def gen_content(xml)
-        xmi_doc = Nokogiri::XML(File.read(xml))
-        @module_name = get_module_name(xmi_doc)
-        @def_namespace = get_namespace_from_definition(xmi_doc)
-        gen_module(xmi_doc, @module_name)
-      end
-
-      def get_module_name(xmi_doc)
-        get_module_name_from_definition(xmi_doc).capitalize
-      end
-
-      def get_module_name_from_definition(xmi_doc)
-        node = xmi_doc.at_xpath("//UMLProfile/Documentation")
-        node.attribute_nodes.find { |attr| attr.name == "name" }&.value
-      end
-
-      def get_module_uri(xmi_doc)
-        node = xmi_doc.at_xpath("//UMLProfile/Documentation")
-        uri = node.attribute_nodes.find { |attr| attr.name == "URI" }&.value
-
-        return uri if uri
-
-        name = get_module_name_from_definition(xmi_doc)
-        ver = node.attribute_nodes.find { |attr| attr.name == "version" }&.value
-
-        "http://www.sparxsystems.com/profiles/#{name}/#{ver}"
-      end
     end
   end
 end

data/lib/xmi/namespace_detector.rb

@@ -10,6 +10,15 @@ module Xmi
   class NamespaceDetector
     VERSION_PATTERN = /(\d{8})/
 
+    # Regex to extract xmlns declarations without parsing the entire document.
+    # Matches both default namespace (xmlns="...") and prefixed (xmlns:foo="...").
+    # Namespace declarations are always on or near the root element, so scanning
+    # the first 8KB is sufficient for any XMI file.
+    NS_DECL_REGEX = /xmlns(?::(\w+))?\s*=\s*["']([^"']+)["']/
+
+    # How many bytes of the XML to scan for namespace declarations
+    NS_SCAN_BYTES = 8192
+
     # Namespace URI patterns for OMG specifications
     NS_PATTERNS = {
       xmi: %r{http://www\.omg\.org/spec/XMI/(\d{8})},
@@ -33,11 +42,34 @@ module Xmi
       }
     end
 
-    # Extract all namespace URIs from XML content
+    # Extract all namespace URIs from XML content using regex on the first 8KB.
     #
-    # @param xml_content [String] The XML content to parse
+    # This avoids a full Nokogiri parse — namespace declarations are always
+    # on or near the root element, so scanning the first few KB is sufficient
+    # and ~10x faster than parsing a 3.5MB document.
+    #
+    # @param xml_content [String] The XML content
     # @return [Hash<String, String>] A hash mapping prefixes to namespace URIs
     def self.extract_namespace_uris(xml_content)
+      head = xml_content.byteslice(0, NS_SCAN_BYTES)
+      unless head.valid_encoding?
+        head = head.encode("UTF-8", invalid: :replace,
+                                    undef: :replace)
+      end
+      result = {}
+      head.scan(NS_DECL_REGEX) do |prefix, uri|
+        key = prefix.nil? ? "xmlns" : prefix
+        result[key] = uri unless result.key?(key)
+      end
+      result
+    end
+
+    # Extract namespace URIs via Nokogiri (full parse).
+    # Used by `analyze` when the complete namespace map is needed.
+    #
+    # @param xml_content [String] The XML content
+    # @return [Hash<String, String>] A hash mapping prefixes to namespace URIs
+    def self.extract_namespace_uris_full(xml_content)
       doc = Nokogiri::XML(xml_content, &:noent)
       doc.collect_namespaces
     rescue Nokogiri::XML::SyntaxError
@@ -117,7 +149,7 @@ module Xmi
     def self.analyze(xml_content)
       versions = detect_versions(xml_content)
       uris = detect_namespace_uris(xml_content)
-      raw_namespaces = extract_namespace_uris(xml_content)
+      raw_namespaces = extract_namespace_uris_full(xml_content)
 
       {
         versions: versions,

data/lib/xmi/parser_pipeline.rb

@@ -8,9 +8,9 @@ module Xmi
   # without modifying existing code — Open/Closed Principle.
   #
   # @example
-  #   context = { xml: xml_content, root_class: Xmi::Sparx::SparxRoot }
+  #   context = { xml: xml_content, root_class: Xmi::Sparx::Root }
   #   result = Xmi::ParserPipeline.run(context)
-  #   result[:root]  # => parsed SparxRoot instance
+  #   result[:root]  # => parsed Root instance
   #
   module ParserPipeline
     module Steps
@@ -18,11 +18,11 @@ module Xmi
         def self.call(ctx)
           xml = ctx[:xml]
           if xml.respond_to?(:valid_encoding?) && !xml.valid_encoding?
-            xml = xml
+            ctx[:xml] = xml
               .encode("UTF-16be", invalid: :replace, replace: "?")
               .encode("UTF-8")
           end
-          ctx.merge(xml: xml)
+          ctx
         end
       end
 
@@ -36,16 +36,16 @@ module Xmi
       module ParseXml
         def self.call(ctx)
           root_class = ctx[:root_class]
-          root = VersionRegistry.parse_with_detected_version(ctx[:xml],
-                                                             root_class)
-          ctx.merge(root: root)
+          ctx[:root] = VersionRegistry.parse_with_detected_version(
+            ctx[:xml], root_class
+          )
+          ctx
         end
       end
 
       module BuildIndex
         def self.call(ctx)
-          root = ctx[:root]
-          root.build_index if root.respond_to?(:build_index)
+          ctx[:root].build_index if ctx[:root].respond_to?(:build_index)
           ctx
         end
       end

data/lib/xmi/sparx/index.rb

@@ -2,7 +2,7 @@
 
 module Xmi
   module Sparx
-    # Builds all commonly needed indexes from a parsed SparxRoot in a single
+    # Builds all commonly needed indexes from a parsed Root in a single
     # targeted walk, avoiding the generic map_id_name approach that visits every
     # attribute of every node.
     #
@@ -24,7 +24,7 @@ module Xmi
 
       PackagedElement = ::Xmi::Uml::PackagedElement
 
-      # @param root [Xmi::Sparx::SparxRoot] parsed XMI model
+      # @param root [Xmi::Sparx::Root] parsed XMI model
       def initialize(root)
         @id_name_map = {}
         @packaged_elements = []

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

@@ -2,15 +2,15 @@
 
 module Xmi
   module Sparx
-    module SparxMappings
+    module Mappings
       # Base XML mapping class for Sparx EA XMI documents.
       #
       # This reusable mapping class encapsulates all the XML element → attribute
-      # mappings for SparxRoot.
+      # mappings for Root.
       #
       # @example Use in a model class
-      #   class SparxRoot < Root
-      #     xml SparxMappings::BaseMapping
+      #   class Root < ::Xmi::Root
+      #     xml Mappings::BaseMapping
       #   end
       class BaseMapping < Lutaml::Xml::Mapping
         xml do

data/lib/xmi/sparx/mappings.rb

@@ -2,7 +2,7 @@
 
 module Xmi
   module Sparx
-    module SparxMappings
+    module Mappings
       # Reusable XML mapping classes for Sparx EA XMI documents.
       autoload :BaseMapping, "xmi/sparx/mappings/base_mapping"
     end

data/lib/xmi/sparx/root.rb

@@ -2,7 +2,7 @@
 
 module Xmi
   module Sparx
-    class SparxRoot < Root
+    class Root < ::Xmi::Root
       attribute :modelica_parameter, SysPhS
 
       attribute :eauml_import, EaUml::Import, collection: true
@@ -26,7 +26,7 @@ module Xmi
         # encoding fix → version detection → XML parsing → index building.
         #
         # @param xml_content [String] The raw XMI XML content
-        # @return [SparxRoot] The parsed Ruby object with index built
+        # @return [Root] The parsed Ruby object with index built
         #
         # @see Xmi::ParserPipeline
         # @see Xmi.parse
@@ -55,7 +55,7 @@ module Xmi
       end
 
       # Use the reusable BaseMapping class instead of eval hack
-      xml SparxMappings::BaseMapping
+      xml Mappings::BaseMapping
 
       # Build index for fast lookups
       # @return [Sparx::Index]

data/lib/xmi/sparx.rb

@@ -17,8 +17,8 @@ module Xmi
     autoload :EaStub, "xmi/sparx/ea_stub"
     autoload :SysPhS, "xmi/sparx/sys_ph_s"
     autoload :Extension, "xmi/sparx/extension"
-    autoload :SparxRoot, "xmi/sparx/root"
-    autoload :SparxMappings, "xmi/sparx/mappings"
+    autoload :Root, "xmi/sparx/root"
+    autoload :Mappings, "xmi/sparx/mappings"
     autoload :Index, "xmi/sparx/index"
   end
 end

data/lib/xmi/version.rb

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