xmi 0.5.3 → 0.5.5

data/lib/xmi/ea_root.rb

@@ -1,58 +1,24 @@
 # 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
+        extension_id = derive_module_name(xml_path)
 
         if loaded_extensions.key?(extension_id)
           raise ArgumentError,
@@ -61,18 +27,11 @@ module Xmi
                 "Call unload_extension('#{extension_id}') first if you want to reload it."
         end
 
-        Object.class_eval @content
+        build_extension(xml_path)
         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,366 +40,20 @@ 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}"
+      def derive_module_name(xml_path)
+        xmi_doc = Nokogiri::XML(File.read(xml_path))
+        get_module_name(xmi_doc)
       end
     end
   end

data/lib/xmi/extension.rb

@@ -2,12 +2,8 @@
 
 module Xmi
   class Extension < Lutaml::Model::Serializable
-    attribute :id, ::Xmi::Type::XmiId
-    attribute :label, ::Xmi::Type::XmiLabel
-    attribute :uuid, ::Xmi::Type::XmiUuid
-    attribute :href, :string
-    attribute :idref, ::Xmi::Type::XmiIdRef
-    attribute :type, ::Xmi::Type::XmiType
+    include XmiIdentity::Attributes
+
     attribute :extender, :string
     attribute :extender_id, :string
 
@@ -15,12 +11,8 @@ module Xmi
       root "Extension"
       namespace ::Xmi::Namespace::Omg::Xmi
 
-      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
-      map_attribute "type", to: :type
+      XmiIdentity.apply_xml_mappings(self)
+
       map_attribute "extender", to: :extender
       map_attribute "extenderID", to: :extender_id
     end

data/lib/xmi/parser_pipeline.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Xmi
+  # Composable pipeline for XMI parsing.
+  #
+  # Each step receives a context hash and returns an updated context hash.
+  # New concerns (validation, logging, caching) are added by inserting steps
+  # without modifying existing code — Open/Closed Principle.
+  #
+  # @example
+  #   context = { xml: xml_content, root_class: Xmi::Sparx::SparxRoot }
+  #   result = Xmi::ParserPipeline.run(context)
+  #   result[:root]  # => parsed SparxRoot instance
+  #
+  module ParserPipeline
+    module Steps
+      module FixEncoding
+        def self.call(ctx)
+          xml = ctx[:xml]
+          if xml.respond_to?(:valid_encoding?) && !xml.valid_encoding?
+            xml = xml
+              .encode("UTF-16be", invalid: :replace, replace: "?")
+              .encode("UTF-8")
+          end
+          ctx.merge(xml: xml)
+        end
+      end
+
+      module InitVersioning
+        def self.call(ctx)
+          Xmi.init_versioning!
+          ctx
+        end
+      end
+
+      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)
+        end
+      end
+
+      module BuildIndex
+        def self.call(ctx)
+          root = ctx[:root]
+          root.build_index if root.respond_to?(:build_index)
+          ctx
+        end
+      end
+    end
+
+    DEFAULT_STEPS = [
+      Steps::FixEncoding,
+      Steps::InitVersioning,
+      Steps::ParseXml,
+      Steps::BuildIndex,
+    ].freeze
+
+    # Run the pipeline with default or custom steps.
+    #
+    # @param ctx [Hash] Initial context with :xml and :root_class
+    # @param steps [Array<Module>] Pipeline steps (defaults to DEFAULT_STEPS)
+    # @return [Hash] Final context including :root
+    def self.run(ctx, steps: DEFAULT_STEPS)
+      steps.reduce(ctx) { |context, step| step.call(context) }
+    end
+  end
+end

data/lib/xmi/root.rb

@@ -5,12 +5,8 @@ require_relative "uml"
 
 module Xmi
   class Root < Lutaml::Model::Serializable
-    attribute :id, ::Xmi::Type::XmiId
-    attribute :label, ::Xmi::Type::XmiLabel
-    attribute :uuid, ::Xmi::Type::XmiUuid
-    attribute :href, :string
-    attribute :idref, ::Xmi::Type::XmiIdRef
-    attribute :type, ::Xmi::Type::XmiType
+    include XmiIdentity::Attributes
+
     attribute :documentation, Documentation
     attribute :bibliography, CustomProfile::Bibliography, collection: true
     attribute :basic_doc, CustomProfile::BasicDoc, collection: true
@@ -44,12 +40,7 @@ module Xmi
         ::Xmi::Namespace::Sparx::CityGml,
       ]
 
-      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
-      map_attribute "type", to: :type
+      XmiIdentity.apply_xml_mappings(self)
 
       map_element "Documentation", to: :documentation
       map_element "Model", to: :model

data/lib/xmi/sparx/connector/appearance.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Connector
+      class Appearance < Lutaml::Model::Serializable
+        attribute :linemode, :integer
+        attribute :linecolor, :integer
+        attribute :linewidth, :integer
+        attribute :seqno, :integer
+        attribute :headStyle, :integer
+        attribute :lineStyle, :integer
+
+        xml do
+          root "appearance"
+
+          map_attribute :linemode, to: :linemode
+          map_attribute :linecolor, to: :linecolor
+          map_attribute :linewidth, to: :linewidth
+          map_attribute :seqno, to: :seqno
+          map_attribute :headStyle, to: :headStyle
+          map_attribute :lineStyle, to: :lineStyle
+        end
+      end
+    end
+  end
+end

data/lib/xmi/sparx/connector/connector.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Connector
+      class Connector < Lutaml::Model::Serializable
+        attribute :name, :string
+        attribute :idref, ::Xmi::Type::XmiIdRef
+        attribute :source, Source
+        attribute :target, Target
+        attribute :model, Model
+        attribute :properties, Properties
+        attribute :documentation, Element::Documentation
+        attribute :appearance, Appearance
+        attribute :labels, Labels
+        attribute :extended_properties, Element::ExtendedProperties
+        attribute :style, Element::Style
+        attribute :tags, Element::Tags
+        attribute :xrefs, Element::Xrefs
+
+        xml do
+          root "element"
+
+          map_attribute "name", to: :name
+          map_attribute "idref", to: :idref
+
+          map_element "source", to: :source
+          map_element "target", to: :target
+          map_element "model", to: :model
+          map_element "properties", to: :properties
+          map_element "documentation", to: :documentation, value_map: VALUE_MAP
+          map_element "appearance", to: :appearance
+          map_element "labels", to: :labels, render_nil: true
+          map_element "extendedProperties", to: :extended_properties
+          map_element "style", to: :style, render_nil: true
+          map_element "xrefs", to: :xrefs, render_nil: true
+          map_element "tags", to: :tags, render_nil: true
+        end
+      end
+
+      class Connectors < Lutaml::Model::Serializable
+        attribute :connector, Connector, collection: true
+
+        xml do
+          root "connectors"
+
+          map_element "connector", to: :connector, value_map: VALUE_MAP
+        end
+      end
+    end
+  end
+end