xmi 0.5.3 → 0.5.5

data/lib/xmi/sparx/gml/type.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Gml
+      class Type < Lutaml::Model::Serializable
+        include HasCollectionProperties
+
+        xml do
+          root "Type"
+          namespace ::Xmi::Namespace::Sparx::Gml
+
+          HasCollectionProperties.apply_xml_mappings(self)
+        end
+      end
+    end
+  end
+end

data/lib/xmi/sparx/gml/union.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Gml
+      class Union < Lutaml::Model::Serializable
+        include HasCollectionProperties
+
+        xml do
+          root "Union"
+          namespace ::Xmi::Namespace::Sparx::Gml
+
+          HasCollectionProperties.apply_xml_mappings(self)
+        end
+      end
+    end
+  end
+end

data/lib/xmi/sparx/gml.rb

@@ -3,131 +3,16 @@
 module Xmi
   module Sparx
     module Gml
-      class ApplicationSchema < Lutaml::Model::Serializable
-        # prefix altered_ is prepended to xmlns to avoid conflict with
-        # reserved keyword
-        attribute :version, :string
-        attribute :xsd_document, :string
-        attribute :altered_xmlns, :string
-        attribute :target_namespace, :string
-        attribute :base_package, :string
-
-        xml do
-          root "ApplicationSchema"
-          namespace ::Xmi::Namespace::Sparx::Gml
-
-          map_attribute "version", to: :version
-          map_attribute "xsdDocument", to: :xsd_document
-          map_attribute "altered_xmlns", to: :altered_xmlns
-          map_attribute "targetNamespace", to: :target_namespace
-          map_attribute "base_Package", to: :base_package
-        end
-      end
-
-      class CodeList < Lutaml::Model::Serializable
-        attribute :as_dictionary, :string
-        attribute :default_code_space, :string
-        attribute :base_class, :string
-
-        xml do
-          root "CodeList"
-          namespace ::Xmi::Namespace::Sparx::Gml
-
-          map_attribute "asDictionary", to: :as_dictionary
-          map_attribute "defaultCodeSpace", to: :default_code_space
-          map_attribute "base_Class", to: :base_class
-        end
-      end
-
-      class DataType < Lutaml::Model::Serializable
-        attribute :is_collection, :string
-        attribute :no_property_type, :string
-        attribute :base_class, :string
-
-        xml do
-          root "DataType"
-          namespace ::Xmi::Namespace::Sparx::Gml
-
-          map_attribute "isCollection", to: :is_collection
-          map_attribute "noPropertyType", to: :no_property_type
-          map_attribute "base_Class", to: :base_class
-        end
-      end
-
-      class Union < Lutaml::Model::Serializable
-        attribute :is_collection, :string
-        attribute :no_property_type, :string
-        attribute :base_class, :string
-
-        xml do
-          root "Union"
-          namespace ::Xmi::Namespace::Sparx::Gml
-
-          map_attribute "isCollection", to: :is_collection
-          map_attribute "noPropertyType", to: :no_property_type
-          map_attribute "base_Class", to: :base_class
-        end
-      end
-
-      class Enumeration < Lutaml::Model::Serializable
-        attribute :base_enumeration, :string
-
-        xml do
-          root "Enumeration"
-          namespace ::Xmi::Namespace::Sparx::Gml
-
-          map_attribute "base_Enumeration", to: :base_enumeration
-        end
-      end
-
-      class Type < Lutaml::Model::Serializable
-        attribute :is_collection, :string
-        attribute :no_property_type, :string
-        attribute :base_class, :string
-
-        xml do
-          root "Type"
-          namespace ::Xmi::Namespace::Sparx::Gml
-
-          map_attribute "isCollection", to: :is_collection
-          map_attribute "noPropertyType", to: :no_property_type
-          map_attribute "base_Class", to: :base_class
-        end
-      end
-
-      class FeatureType < Lutaml::Model::Serializable
-        attribute :is_collection, :string
-        attribute :no_property_type, :string
-        attribute :base_class, :string
-        attribute :by_value_property_type, :string
-
-        xml do
-          root "FeatureType"
-          namespace ::Xmi::Namespace::Sparx::Gml
-
-          map_attribute "isCollection", to: :is_collection
-          map_attribute "noPropertyType", to: :no_property_type
-          map_attribute "base_Class", to: :base_class
-          map_attribute "byValuePropertyType", to: :by_value_property_type
-        end
-      end
-
-      class Property < Lutaml::Model::Serializable
-        attribute :sequence_number, :string
-        attribute :base_property, :string
-        attribute :is_metadata, :string
-        attribute :inline_or_by_reference, :string
-
-        xml do
-          root "property"
-          namespace ::Xmi::Namespace::Sparx::Gml
-
-          map_attribute "sequenceNumber", to: :sequence_number
-          map_attribute "base_Property", to: :base_property
-          map_attribute "isMetadata", to: :is_metadata
-          map_attribute "inlineOrByReference", to: :inline_or_by_reference
-        end
-      end
+      autoload :HasBaseClass, "xmi/sparx/gml/shared_attributes"
+      autoload :HasCollectionProperties, "xmi/sparx/gml/shared_attributes"
+      autoload :ApplicationSchema, "xmi/sparx/gml/application_schema"
+      autoload :CodeList, "xmi/sparx/gml/code_list"
+      autoload :DataType, "xmi/sparx/gml/data_type"
+      autoload :Union, "xmi/sparx/gml/union"
+      autoload :Enumeration, "xmi/sparx/gml/enumeration"
+      autoload :Type, "xmi/sparx/gml/type"
+      autoload :FeatureType, "xmi/sparx/gml/feature_type"
+      autoload :Property, "xmi/sparx/gml/property"
     end
   end
 end

data/lib/xmi/sparx/index.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    # Builds all commonly needed indexes from a parsed SparxRoot in a single
+    # targeted walk, avoiding the generic map_id_name approach that visits every
+    # attribute of every node.
+    #
+    # Indexes built:
+    # - id_name_map: { xmi_id => name } for all nodes with both id and name
+    # - packaged_elements: flat array of all PackagedElement instances
+    # - packaged_by_id: { xmi_id => PackagedElement }
+    # - packaged_by_type: { "uml:Class" => [...], "uml:Package" => [...], ... }
+    # - upper_level_map: { xmi_id => parent PackagedElement }
+    # - elements_by_idref: { idref => Extension::Element::Element }
+    # - connectors_by_idref: { idref => Connector::Connector }
+    # - attributes_by_idref: { idref => Extension::Element::Attribute }
+    # - owned_attrs_by_type_idref: { type_idref => [OwnedAttribute, ...] }
+    class Index
+      attr_reader :id_name_map, :packaged_elements, :packaged_by_id,
+                  :packaged_by_type, :upper_level_map, :elements_by_idref,
+                  :connectors_by_idref, :attributes_by_idref,
+                  :owned_attrs_by_type_idref
+
+      PackagedElement = ::Xmi::Uml::PackagedElement
+
+      # @param root [Xmi::Sparx::SparxRoot] parsed XMI model
+      def initialize(root)
+        @id_name_map = {}
+        @packaged_elements = []
+        @packaged_by_id = {}
+        @packaged_by_type = {}
+        @upper_level_map = {}
+        @elements_by_idref = {}
+        @connectors_by_idref = {}
+        @attributes_by_idref = {}
+        @owned_attrs_by_type_idref = {}
+
+        build(root)
+        freeze
+      end
+
+      # Lookup name by XMI ID
+      # @param xmi_id [String] XMI identifier
+      # @return [String, nil]
+      def lookup_name(xmi_id)
+        @id_name_map[xmi_id]
+      end
+
+      # Find packaged element by XMI ID
+      # @param id [String]
+      # @return [Xmi::Uml::PackagedElement, nil]
+      def find_packaged_element(id)
+        @packaged_by_id[id]
+      end
+
+      # Find parent of a packaged element
+      # @param id [String] child XMI ID
+      # @return [Xmi::Uml::PackagedElement, nil]
+      def find_parent(id)
+        @upper_level_map[id]
+      end
+
+      # Find extension element by idref
+      # @param idref [String]
+      # @return [Xmi::Sparx::Element::Element, nil]
+      def find_element(idref)
+        @elements_by_idref[idref]
+      end
+
+      # Find connector by idref
+      # @param idref [String]
+      # @return [Xmi::Sparx::Connector::Connector, nil]
+      def find_connector(idref)
+        @connectors_by_idref[idref]
+      end
+
+      # Find extension attribute by idref
+      # @param idref [String]
+      # @return [Xmi::Sparx::Element::Attribute, nil]
+      def find_attribute(idref)
+        @attributes_by_idref[idref]
+      end
+
+      # Find owned attributes whose uml_type.idref matches
+      # @param type_idref [String]
+      # @return [Array<Xmi::Uml::OwnedAttribute>]
+      def find_owned_attrs_by_type(type_idref)
+        @owned_attrs_by_type_idref[type_idref] || []
+      end
+
+      # Find packaged elements by UML type
+      # @param type [String] e.g. "uml:Class", "uml:Package"
+      # @return [Array<Xmi::Uml::PackagedElement>]
+      def packaged_elements_of_type(type)
+        @packaged_by_type[type] || []
+      end
+
+      # Find first packaged element by name and allowed types
+      # @param name [String]
+      # @param types [Array<String>] e.g. ["uml:Class", "uml:AssociationClass"]
+      # @return [Xmi::Uml::PackagedElement, nil]
+      def find_packaged_by_name_and_types(name, types)
+        types.each do |type|
+          elements = @packaged_by_type[type]
+          next unless elements
+
+          found = elements.find { |e| e.name == name }
+          return found if found
+        end
+        nil
+      end
+
+      private
+
+      def build(root)
+        model = root.model
+        if model
+          id = model.id if model.respond_to?(:id)
+          @id_name_map[id] = model.name if id && model.name
+          walk_packaged_elements(model.packaged_element, nil)
+        end
+
+        ext = root.extension
+        return unless ext
+
+        index_extension_elements(ext.elements)
+        index_extension_connectors(ext.connectors)
+
+        primitives = ext.primitive_types
+        walk_packaged_elements(primitives.packaged_element, nil) if primitives
+
+        index_extension_profiles(ext.profiles)
+      end
+
+      def walk_packaged_elements(elements, parent) # rubocop:disable Metrics/MethodLength
+        return unless elements
+
+        id_name_map = @id_name_map
+        packaged_by_id = @packaged_by_id
+        packaged_by_type = @packaged_by_type
+        upper_level_map = @upper_level_map
+        packaged_elements = @packaged_elements
+        owned_attrs_by_type = @owned_attrs_by_type_idref
+
+        elements.each do |pe|
+          next unless pe.is_a?(PackagedElement)
+
+          pe_id = pe.id
+          pe_type = pe.type
+          pe_name = pe.name
+
+          packaged_elements << pe
+          packaged_by_id[pe_id] = pe if pe_id
+          (packaged_by_type[pe_type] ||= []) << pe if pe_type
+          upper_level_map[pe_id] = parent if parent && pe_id
+          id_name_map[pe_id] = pe_name if pe_id && pe_name
+
+          # Inline owned attribute indexing
+          attrs = pe.owned_attribute
+          if attrs && !attrs.empty?
+            attrs.each do |oa|
+              oa_id = oa.id
+              id_name_map[oa_id] = oa.name if oa_id && oa.name
+              oa_type = oa.uml_type
+              if oa.association && oa_type && oa_type.idref
+                (owned_attrs_by_type[oa_type.idref] ||= []) << oa
+              end
+            end
+          end
+
+          # Inline owned operation indexing
+          ops = pe.owned_operation
+          if ops && !ops.empty?
+            ops.each do |oo|
+              oo_id = oo.id
+              id_name_map[oo_id] = oo.name if oo_id && oo.name
+            end
+          end
+
+          # Inline owned literal indexing
+          lits = pe.owned_literal
+          if lits && !lits.empty?
+            lits.each do |ol|
+              ol_id = ol.id
+              id_name_map[ol_id] = ol.name if ol_id && ol.name
+            end
+          end
+
+          # Recurse into children
+          walk_packaged_elements(pe.packaged_element, pe)
+        end
+      end
+
+      def index_extension_elements(elements)
+        return unless elements
+
+        element_list = elements.element
+        return unless element_list
+
+        element_list.each do |e|
+          idref = e.idref
+          next unless idref
+
+          @elements_by_idref[idref] = e
+
+          props = e.properties
+          @id_name_map[idref] = props.name if props&.name
+
+          attrs_obj = e.attributes
+          next unless attrs_obj
+
+          attr_list = attrs_obj.attribute
+          next unless attr_list
+
+          attr_list.each do |a|
+            @attributes_by_idref[a.idref] = a if a.idref
+          end
+        end
+      end
+
+      def index_extension_connectors(connectors)
+        return unless connectors
+
+        conn_list = connectors.connector
+        return unless conn_list
+
+        conn_list.each do |c|
+          @connectors_by_idref[c.idref] = c if c.idref
+        end
+      end
+
+      def index_extension_profiles(profiles)
+        return unless profiles
+
+        profile_list = profiles.profile
+        return unless profile_list
+
+        profile_list.each do |profile|
+          if profile.respond_to?(:packaged_element)
+            walk_packaged_elements(profile.packaged_element,
+                                   nil)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,17 +6,12 @@ module Xmi
       # Base XML mapping class for Sparx EA XMI documents.
       #
       # This reusable mapping class encapsulates all the XML element → attribute
-      # mappings for SparxRoot, eliminating the previous eval hack.
+      # mappings for SparxRoot.
       #
       # @example Use in a model class
       #   class SparxRoot < Root
       #     xml SparxMappings::BaseMapping
       #   end
-      #
-      # @example Extend with additional mappings
-      #   class ExtendedRoot < Root
-      #     xml SparxMappings::GmlMapping
-      #   end
       class BaseMapping < Lutaml::Xml::Mapping
         xml do
           # Set the default namespace for element name resolution
@@ -35,6 +30,8 @@ module Xmi
             ::Xmi::Namespace::Sparx::CityGml,
           ]
 
+          VM = ::Xmi::VALUE_MAP
+
           # Extension element containing Sparx EA-specific metadata
           map_element "Extension", to: :extension
 
@@ -42,139 +39,18 @@ module Xmi
           map_element "ModelicaParameter", to: :modelica_parameter
 
           # UML import elements (EAUML profile)
-          map_element "import", to: :eauml_import,
-                                value_map: {
-                                  from: {
-                                    nil: :empty,
-                                    empty: :empty,
-                                    omitted: :empty,
-                                  },
-                                  to: {
-                                    nil: :empty,
-                                    empty: :empty,
-                                    omitted: :empty,
-                                  },
-                                }
+          map_element "import", to: :eauml_import, value_map: VM
 
-          # GML ApplicationSchema elements
+          # GML elements
           map_element "ApplicationSchema", to: :gml_application_schema,
-                                           value_map: {
-                                             from: {
-                                               nil: :empty,
-                                               empty: :empty,
-                                               omitted: :empty,
-                                             },
-                                             to: {
-                                               nil: :empty,
-                                               empty: :empty,
-                                               omitted: :empty,
-                                             },
-                                           }
-
-          # GML CodeList elements
-          map_element "CodeList", to: :gml_code_list,
-                                  value_map: {
-                                    from: {
-                                      nil: :empty,
-                                      empty: :empty,
-                                      omitted: :empty,
-                                    },
-                                    to: {
-                                      nil: :empty,
-                                      empty: :empty,
-                                      omitted: :empty,
-                                    },
-                                  }
-
-          # GML DataType elements
-          map_element "DataType", to: :gml_data_type,
-                                  value_map: {
-                                    from: {
-                                      nil: :empty,
-                                      empty: :empty,
-                                      omitted: :empty,
-                                    },
-                                    to: {
-                                      nil: :empty,
-                                      empty: :empty,
-                                      omitted: :empty,
-                                    },
-                                  }
-
-          # GML Union elements
-          map_element "Union", to: :gml_union,
-                               value_map: {
-                                 from: {
-                                   nil: :empty,
-                                   empty: :empty,
-                                   omitted: :empty,
-                                 },
-                                 to: {
-                                   nil: :empty,
-                                   empty: :empty,
-                                   omitted: :empty,
-                                 },
-                               }
-
-          # GML Enumeration elements
-          map_element "Enumeration", to: :gml_enumeration,
-                                     value_map: {
-                                       from: {
-                                         nil: :empty,
-                                         empty: :empty,
-                                         omitted: :empty,
-                                       },
-                                       to: {
-                                         nil: :empty,
-                                         empty: :empty,
-                                         omitted: :empty,
-                                       },
-                                     }
-
-          # GML Type elements
-          map_element "Type", to: :gml_type,
-                              value_map: {
-                                from: {
-                                  nil: :empty,
-                                  empty: :empty,
-                                  omitted: :empty,
-                                },
-                                to: {
-                                  nil: :empty,
-                                  empty: :empty,
-                                  omitted: :empty,
-                                },
-                              }
-
-          # GML FeatureType elements
-          map_element "FeatureType", to: :gml_feature_type,
-                                     value_map: {
-                                       from: {
-                                         nil: :empty,
-                                         empty: :empty,
-                                         omitted: :empty,
-                                       },
-                                       to: {
-                                         nil: :empty,
-                                         empty: :empty,
-                                         omitted: :empty,
-                                       },
-                                     }
-
-          # GML property elements
-          map_element "property", to: :gml_property,
-                                  value_map: {
-                                    from: {
-                                      nil: :empty,
-                                      empty: :empty,
-                                      omitted: :empty,
-                                    },
-                                    to: {
-                                      nil: :empty,
-                                      empty: :empty,
-                                      omitted: :empty,
-                                    },
-                                  }
+                                           value_map: VM
+          map_element "CodeList", to: :gml_code_list, value_map: VM
+          map_element "DataType", to: :gml_data_type, value_map: VM
+          map_element "Union", to: :gml_union, value_map: VM
+          map_element "Enumeration", to: :gml_enumeration, value_map: VM
+          map_element "Type", to: :gml_type, value_map: VM
+          map_element "FeatureType", to: :gml_feature_type, value_map: VM
+          map_element "property", to: :gml_property, value_map: VM
         end
       end
     end

data/lib/xmi/sparx/root.rb

@@ -22,20 +22,19 @@ module Xmi
       class << self
         # Parse XMI content into Ruby objects.
         #
-        # This method uses automatic version detection to handle different XMI
-        # namespace versions (e.g., XMI 20110701, 20131001, 20161101) and
-        # their corresponding UML versions.
+        # Uses the ParserPipeline for composable parsing steps:
+        # 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
         #
+        # @see Xmi::ParserPipeline
         # @see Xmi.parse
         def parse_xml(xml_content)
-          xml_content = fix_encoding(xml_content)
-          Xmi.init_versioning!
-          root = Xmi::VersionRegistry.parse_with_detected_version(xml_content, self)
-          root.build_index
-          root
+          ctx = ParserPipeline.run(
+            { xml: xml_content, root_class: self },
+          )
+          ctx[:root]
         end
 
         # Fix invalid UTF-8 encoding in the XML content.
@@ -59,13 +58,13 @@ module Xmi
       xml SparxMappings::BaseMapping
 
       # Build index for fast lookups
-      # @return [Xmi::Index]
+      # @return [Sparx::Index]
       def build_index
-        @index = Xmi::Index.new(self)
+        @index = Index.new(self)
       end
 
       # Access the index (builds on first access if needed)
-      # @return [Xmi::Index]
+      # @return [Sparx::Index]
       def index
         @index || build_index
       end

data/lib/xmi/sparx.rb

@@ -19,5 +19,6 @@ module Xmi
     autoload :Extension, "xmi/sparx/extension"
     autoload :SparxRoot, "xmi/sparx/root"
     autoload :SparxMappings, "xmi/sparx/mappings"
+    autoload :Index, "xmi/sparx/index"
   end
 end

data/lib/xmi/uml/annotated_element.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Uml
+    class AnnotatedElement < Lutaml::Model::Serializable
+      attribute :idref, ::Xmi::Type::XmiIdRef
+
+      xml do
+        root "annotatedElement"
+        namespace ::Xmi::Namespace::Omg::Uml
+
+        map_attribute "idref", to: :idref
+      end
+    end
+  end
+end