xmi 0.5.2 → 0.5.4

data/lib/xmi/sparx/extension.rb

@@ -3,12 +3,8 @@
 module Xmi
   module Sparx
     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
       attribute :elements, Element::Elements
@@ -22,12 +18,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
 

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Gml
+      class ApplicationSchema < Lutaml::Model::Serializable
+        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
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Gml
+      class CodeList < Lutaml::Model::Serializable
+        include HasBaseClass
+
+        attribute :as_dictionary, :string
+        attribute :default_code_space, :string
+
+        xml do
+          root "CodeList"
+          namespace ::Xmi::Namespace::Sparx::Gml
+
+          HasBaseClass.apply_xml_mappings(self)
+          map_attribute "asDictionary", to: :as_dictionary
+          map_attribute "defaultCodeSpace", to: :default_code_space
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Gml
+      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
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Gml
+      class FeatureType < Lutaml::Model::Serializable
+        include HasCollectionProperties
+
+        attribute :by_value_property_type, :string
+
+        xml do
+          root "FeatureType"
+          namespace ::Xmi::Namespace::Sparx::Gml
+
+          HasCollectionProperties.apply_xml_mappings(self)
+          map_attribute "byValuePropertyType", to: :by_value_property_type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Gml
+      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
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module Gml
+      # Shared attribute modules for GML stereotype classes.
+      # Reduces duplication across DataType, Type, FeatureType, etc.
+
+      module HasBaseClass
+        def self.included(klass)
+          klass.class_eval do
+            attribute :base_class, :string
+          end
+        end
+
+        def self.apply_xml_mappings(mapping)
+          mapping.map_attribute "base_Class", to: :base_class
+        end
+      end
+
+      module HasCollectionProperties
+        def self.included(klass)
+          klass.class_eval do
+            include HasBaseClass
+
+            attribute :is_collection, :string
+            attribute :no_property_type, :string
+          end
+        end
+
+        def self.apply_xml_mappings(mapping)
+          HasBaseClass.apply_xml_mappings(mapping)
+          mapping.map_attribute "isCollection", to: :is_collection
+          mapping.map_attribute "noPropertyType", to: :no_property_type
+        end
+      end
+    end
+  end
+end

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