lutaml 0.10.13 → 0.10.14

data/lib/lutaml/qea/factory/generalization_builder.rb

@@ -9,7 +9,7 @@ module Lutaml
   module Qea
     module Factory
       class GeneralizationBuilder < BaseTransformer
-        def load_generalization(object_id, visited = Set.new, is_leaf = true) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity,Style/OptionalBooleanParameter
+        def load_generalization(object_id, visited = Set.new, is_leaf = true) # rubocop:disable Style/OptionalBooleanParameter
           return nil if object_id.nil?
 
           if visited.include?(object_id)
@@ -23,58 +23,13 @@ module Lutaml
           current_obj = find_object_by_id(object_id)
           return nil unless current_obj
 
-          ea_connector = database.connectors_for_object(object_id)
-            .find { |c| c.generalization? && c.start_object_id == object_id }
-
-          gen_transformer = GeneralizationTransformer.new(database)
-          generalization = if ea_connector.nil?
-                             gen_transformer.transform(nil, current_obj)
-                           else
-                             gen_transformer.transform(ea_connector,
-                                                       current_obj)
-                           end
+          generalization = build_generalization(object_id, current_obj)
           return nil unless generalization
 
-          current_attrs = load_attributes(object_id)
-          current_assoc_attrs = AssociationBuilder.new(database)
-            .load_association_attributes(object_id)
-          general_attrs = convert_to_general_attributes(
-            current_attrs + current_assoc_attrs,
-          )
-
-          upper_klass = generalization.general_upper_klass
-          gen_name = generalization.general_name
-          general_attrs.each do |attr|
-            attr.gen_name = gen_name
-            name_ns = case attr.type_ns
-                      when "core", "gml"
-                        upper_klass
-                      else
-                        attr.type_ns
-                      end
-            attr.name_ns = name_ns || upper_klass
-          end
+          populate_generalization_attrs(generalization, object_id)
 
-          generalization.general_attributes = general_attrs
-            .sort_by { |a| [a.name.to_s, a.id] }
-
-          generalization.attributes = transform_general_attributes(
-            generalization,
-          )
-
-          generalization.owned_props = generalization.attributes
-            .reject(&:has_association)
-          generalization.assoc_props = generalization.attributes
-            .select(&:has_association)
-
-          parent_object_id = ea_connector&.end_object_id
-          if parent_object_id
-            parent_gen = load_generalization(parent_object_id, visited, false)
-            if parent_gen
-              generalization.general = parent_gen
-              generalization.has_general = true
-            end
-          end
+          ea_connector = ea_connector_for(object_id)
+          populate_parent_generalization(generalization, ea_connector, visited)
 
           if is_leaf && generalization.has_general
             collect_inherited_properties(generalization)
@@ -90,55 +45,155 @@ module Lutaml
             .select { |c| c.generalization? && c.start_object_id == object_id }
 
           gen_connectors.filter_map do |ea_connector|
-            guid = ea_connector.ea_guid
-            parent_object_id = ea_connector.end_object_id
+            build_assoc_generalization(ea_connector)
+          end
+        end
 
-            parent_obj = find_object_by_id(parent_object_id)
-            next unless parent_obj
+        def convert_to_general_attributes(attributes)
+          attributes.map { |attr| to_general_attribute(attr) }
+        end
 
-            Lutaml::Uml::AssociationGeneralization.new.tap do |ag|
-              ag.id = normalize_guid_to_xmi_format(guid, "EAID")
-              ag.type = "uml:Generalization"
-              ag.general = normalize_guid_to_xmi_format(parent_obj.ea_guid,
-                                                        "EAID")
-            end
+        def convert_to_top_element_attributes(attributes)
+          attributes.map { |attr| to_top_element_attribute(attr) }
+        end
+
+        def to_general_attribute(attr)
+          base = base_attr_hash(attr)
+          Lutaml::Uml::GeneralAttribute.new.tap do |gen_attr|
+            base.each { |k, v| gen_attr.public_send(:"#{k}=", v) }
+            gen_attr.is_derived = !!attr.is_derived
+            gen_attr.has_association = !!attr.association
           end
         end
 
-        def convert_to_general_attributes(attributes)
-          attributes.map do |attr|
-            Lutaml::Uml::GeneralAttribute.new.tap do |gen_attr|
-              gen_attr.id = attr.id
-              gen_attr.name = attr.name
-              gen_attr.type = attr.type
-              gen_attr.xmi_id = attr.xmi_id
-              gen_attr.is_derived = !!attr.is_derived
-              gen_attr.cardinality = attr.cardinality
-              gen_attr.definition = attr.definition&.strip
-              gen_attr.association = attr.association
-              gen_attr.has_association = !!attr.association
-              gen_attr.type_ns = attr.type_ns
+        def to_top_element_attribute(attr)
+          base = base_attr_hash(attr)
+          Lutaml::Uml::TopElementAttribute.new.tap do |top_attr|
+            base.each { |k, v| top_attr.public_send(:"#{k}=", v) }
+            top_attr.is_derived = !!attr.is_derived
+          end
+        end
+
+        def base_attr_hash(attr)
+          {
+            id: attr.id,
+            name: attr.name,
+            type: attr.type,
+            xmi_id: attr.xmi_id,
+            cardinality: attr.cardinality,
+            definition: attr.definition&.strip,
+            association: attr.association,
+            type_ns: attr.type_ns,
+          }
+        end
+
+        private
+
+        def tag_ancestor_attributes(gen, level)
+          [gen.general_attributes, gen.attributes].each do |attr_list|
+            attr_list&.each do |attr|
+              attr.upper_klass = gen.general_upper_klass
+              attr.level = level
             end
           end
         end
 
-        def convert_to_top_element_attributes(attributes)
-          attributes.map do |attr|
-            Lutaml::Uml::TopElementAttribute.new.tap do |top_attr|
-              top_attr.id = attr.id
-              top_attr.name = attr.name
-              top_attr.type = attr.type
-              top_attr.xmi_id = attr.xmi_id
-              top_attr.cardinality = attr.cardinality
-              top_attr.definition = attr.definition&.strip
-              top_attr.association = attr.association
-              top_attr.type_ns = attr.type_ns
-              top_attr.is_derived = !!attr.is_derived
+        def collect_ancestor_attrs(gen, level, inherited_props,
+                                   inherited_assoc_props)
+          gen.attributes.reverse_each do |attr|
+            inherited_attr = attr.dup
+            inherited_attr.upper_klass = gen.general_upper_klass
+            inherited_attr.gen_name = gen.general_name
+            inherited_attr.level = level
+
+            if attr.has_association
+              inherited_assoc_props << inherited_attr
+            else
+              inherited_props << inherited_attr
             end
           end
         end
 
-        private
+        def build_assoc_generalization(ea_connector)
+          parent_obj = find_object_by_id(ea_connector.end_object_id)
+          return nil unless parent_obj
+
+          Lutaml::Uml::AssociationGeneralization.new.tap do |ag|
+            ag.id = normalize_guid_to_xmi_format(ea_connector.ea_guid, "EAID")
+            ag.type = "uml:Generalization"
+            ag.general = normalize_guid_to_xmi_format(parent_obj.ea_guid,
+                                                      "EAID")
+          end
+        end
+
+        def resolve_name_ns(type_ns, upper_klass)
+          ns = case type_ns
+               when "core", "gml"
+                 upper_klass
+               else
+                 type_ns
+               end
+          ns || upper_klass
+        end
+
+        def build_generalization(object_id, current_obj)
+          ea_connector = ea_connector_for(object_id)
+          gen_transformer = GeneralizationTransformer.new(database)
+          if ea_connector.nil?
+            gen_transformer.transform(nil, current_obj)
+          else
+            gen_transformer.transform(ea_connector, current_obj)
+          end
+        end
+
+        def ea_connector_for(object_id)
+          database.connectors_for_object(object_id)
+            .find { |c| c.generalization? && c.start_object_id == object_id }
+        end
+
+        def populate_generalization_attrs(generalization, object_id)
+          general_attrs = build_general_attrs(object_id)
+          apply_namespace_to_attrs(general_attrs, generalization)
+
+          generalization.general_attributes = general_attrs
+            .sort_by { |a| [a.name.to_s, a.id] }
+
+          generalization.attributes = transform_general_attributes(
+            generalization,
+          )
+
+          generalization.owned_props = generalization.attributes
+            .reject(&:has_association)
+          generalization.assoc_props = generalization.attributes
+            .select(&:has_association)
+        end
+
+        def build_general_attrs(object_id)
+          current_attrs = load_attributes(object_id)
+          current_assoc_attrs = AssociationBuilder.new(database)
+            .load_association_attributes(object_id)
+          convert_to_general_attributes(current_attrs + current_assoc_attrs)
+        end
+
+        def apply_namespace_to_attrs(general_attrs, generalization)
+          upper_klass = generalization.general_upper_klass
+          general_attrs.each do |attr|
+            attr.gen_name = generalization.general_name
+            attr.name_ns = resolve_name_ns(attr.type_ns, upper_klass)
+          end
+        end
+
+        def populate_parent_generalization(generalization, ea_connector,
+visited)
+          parent_object_id = ea_connector&.end_object_id
+          return unless parent_object_id
+
+          parent_gen = load_generalization(parent_object_id, visited, false)
+          return unless parent_gen
+
+          generalization.general = parent_gen
+          generalization.has_general = true
+        end
 
         def load_attributes(object_id)
           return [] if object_id.nil?
@@ -152,18 +207,10 @@ module Lutaml
         def transform_general_attributes(generalization)
           upper_klass = generalization.general_upper_klass
           gen_name = generalization.general_name
-          gen_attrs = generalization.general_attributes
 
-          gen_attrs.map do |attr|
+          generalization.general_attributes.map do |attr|
             transformed = attr.dup
-            name_ns = case attr.type_ns
-                      when "core", "gml"
-                        upper_klass
-                      else
-                        attr.type_ns
-                      end
-            name_ns = upper_klass if name_ns.nil?
-            transformed.name_ns = name_ns
+            transformed.name_ns = resolve_name_ns(attr.type_ns, upper_klass)
             transformed.gen_name = gen_name
             transformed.name = "" if transformed.name.nil?
             transformed
@@ -177,26 +224,9 @@ module Lutaml
 
           current_gen = generalization.general
           while current_gen
-            [current_gen.general_attributes,
-             current_gen.attributes].each do |attr_list|
-              attr_list&.each do |attr|
-                attr.upper_klass = current_gen.general_upper_klass
-                attr.level = level
-              end
-            end
-
-            current_gen.attributes.reverse_each do |attr|
-              inherited_attr = attr.dup
-              inherited_attr.upper_klass = current_gen.general_upper_klass
-              inherited_attr.gen_name = current_gen.general_name
-              inherited_attr.level = level
-
-              if attr.has_association
-                inherited_assoc_props << inherited_attr
-              else
-                inherited_props << inherited_attr
-              end
-            end
+            tag_ancestor_attributes(current_gen, level)
+            collect_ancestor_attrs(current_gen, level, inherited_props,
+                                   inherited_assoc_props)
 
             level += 1
             current_gen = current_gen.general

data/lib/lutaml/qea/factory/stereotype_loader.rb

@@ -12,21 +12,27 @@ module Lutaml
           return nil if ea_guid.nil?
           return nil unless @database.xrefs
 
-          xref = @database.xrefs.find do |x|
+          xref = find_stereotype_xref(ea_guid)
+          return nil unless xref
+
+          extract_stereotype_name(xref.description)
+        end
+
+        private
+
+        def find_stereotype_xref(ea_guid)
+          @database.xrefs.find do |x|
             x.client == ea_guid && x.name == "Stereotypes" &&
               x.type == "element property"
           end
+        end
 
-          return nil unless xref
-
-          description = xref.description
+        def extract_stereotype_name(description)
           return nil if description.nil? || description.empty?
 
           if description =~ /@STEREO;Name=([^;]+);/
-            return Regexp.last_match(1)
+            Regexp.last_match(1)
           end
-
-          nil
         end
       end
     end

data/lib/lutaml/qea/lookup_indexes.rb

@@ -30,6 +30,11 @@ module Lutaml
 
       # Eagerly build all lazy lookup indexes before freezing
       def build_lookup_indexes
+        build_primary_indexes
+        build_secondary_indexes
+      end
+
+      def build_primary_indexes
         @objects_by_guid = build_group_index(objects, :ea_guid, single: true)
         @attributes_by_object_id = build_group_index(attributes, :ea_object_id)
         @operations_by_object_id = build_group_index(operations, :ea_object_id)
@@ -42,7 +47,9 @@ module Lutaml
         @diagrams_by_package_id = build_group_index(diagrams, :package_id)
         @diagram_objects_by_id = build_group_index(diagram_objects, :diagram_id)
         @diagram_links_by_id = build_group_index(diagram_links, :diagramid)
-        # Also build hash indexes for find_* methods
+      end
+
+      def build_secondary_indexes
         @packages_by_id = build_group_index(packages, :package_id, single: true)
         @connectors_by_id = build_group_index(connectors, :connector_id,
                                               single: true)

data/lib/lutaml/uml_repository/exporters/markdown/class_page_builder.rb

@@ -39,7 +39,7 @@ module Lutaml
 
               ---
 
-              [Back to Package](#{@link_resolver.package_link(pkg_path)}) | [Back to Index](../index.md)
+              #{build_navigation_links(pkg_path)}
             MARKDOWN
           end
 
@@ -67,21 +67,8 @@ module Lutaml
             return "" if parent.nil? && children.empty?
 
             content = "## Inheritance\n\n"
-
-            if parent
-              parent_qname = @link_resolver.qualified_name(parent)
-              content += "**Extends**: [#{parent.name}](#{@link_resolver.class_link(parent_qname)})\n\n"
-            end
-
-            if children.any?
-              content += "**Extended by**:\n\n"
-              children.each do |child|
-                child_qname = @link_resolver.qualified_name(child)
-                content += "- [#{child.name}](#{@link_resolver.class_link(child_qname)})\n"
-              end
-              content += "\n"
-            end
-
+            content += build_parent_link(parent) if parent
+            content += build_children_links(children) if children.any?
             content
           rescue StandardError
             ""
@@ -138,15 +125,7 @@ module Lutaml
           end
 
           def format_association_row(association, klass)
-            source_end = association.member_end&.first
-            target_end = association.member_end&.last
-
-            end_obj = if source_end&.type&.xmi_id == klass.xmi_id
-                        target_end
-                      else
-                        source_end
-                      end
-
+            end_obj = resolve_target_end(association, klass)
             return "" unless end_obj&.type
 
             target_qname = @link_resolver.qualified_name(end_obj.type)
@@ -172,6 +151,35 @@ module Lutaml
 
             "#{content}\n"
           end
+
+          def build_navigation_links(pkg_path)
+            "[Back to Package](#{@link_resolver.package_link(pkg_path)}) | [Back to Index](../index.md)"
+          end
+
+          def build_parent_link(parent)
+            parent_qname = @link_resolver.qualified_name(parent)
+            "**Extends**: [#{parent.name}](#{@link_resolver.class_link(parent_qname)})\n\n"
+          end
+
+          def build_children_links(children)
+            content = "**Extended by**:\n\n"
+            children.each do |child|
+              child_qname = @link_resolver.qualified_name(child)
+              content += "- [#{child.name}](#{@link_resolver.class_link(child_qname)})\n"
+            end
+            "#{content}\n"
+          end
+
+          def resolve_target_end(association, klass)
+            source_end = association.member_end&.first
+            target_end = association.member_end&.last
+
+            if source_end&.type&.xmi_id == klass.xmi_id
+              target_end
+            else
+              source_end
+            end
+          end
         end
       end
     end

data/lib/lutaml/uml_repository/index_builders/association_index.rb

@@ -3,28 +3,35 @@
 module Lutaml
   module UmlRepository
     class IndexBuilder
-      def build_association_index # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        # Collect document-level associations (XMI format)
+      def build_association_index
+        index_document_associations
+        index_class_level_associations
+      end
+
+      def index_document_associations
         @document.associations&.each do |assoc|
           next unless assoc.xmi_id
 
           @associations[assoc.xmi_id] = assoc
         end
+      end
 
-        # Collect class-level associations (QEA/EA format)
-        # Note: This requires qualified_names index to be built first
+      def index_class_level_associations
         @qualified_names.each_value do |klass|
-          next unless (klass.is_a?(Lutaml::Uml::Class) || klass.is_a?(Lutaml::Uml::DataType)) && klass.associations
+          next unless klassifiable?(klass) && klass.associations
 
           klass.associations.each do |assoc|
             next unless assoc.xmi_id
 
-            # Avoid duplicates - only add if not already present
             @associations[assoc.xmi_id] ||= assoc
           end
         end
       end
 
+      def klassifiable?(klass)
+        klass.is_a?(Lutaml::Uml::Class) || klass.is_a?(Lutaml::Uml::DataType)
+      end
+
       # Build the inheritance graph index
       #
       # Creates a hash mapping parent qualified names to arrays of
@@ -49,46 +56,46 @@ module Lutaml
       #
       # @param classes [Array<Lutaml::Uml::Class>] Classes to process
       # @param package_path [String] Package path for these classes
-      def process_generalizations(classes, package_path) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      def process_generalizations(classes, package_path)
         return unless classes
 
         classes.each do |klass|
           next unless klass.name
 
           child_qname = "#{package_path}::#{klass.name}"
+          index_generalization_edge(child_qname, klass, package_path)
+          index_inheritance_assoc_edges(child_qname, klass, package_path)
+        end
+      end
 
-          # Handle generalization attribute
-          if klass.generalization
-            parent_name = extract_parent_name(klass.generalization)
-            if parent_name
-              parent_qname = resolve_qualified_name(parent_name, package_path)
-              if parent_qname && child_qname != parent_qname
-                @inheritance_graph[parent_qname] ||= []
-                @inheritance_graph[parent_qname] << child_qname
-              end
-            end
-          end
+      def index_generalization_edge(child_qname, klass, package_path)
+        return unless klass.generalization
 
-          # Handle inheritance associations
-          next unless klass.associations
+        parent_name = extract_parent_name(klass.generalization)
+        return unless parent_name
 
-          klass.associations.each do |assoc|
-            next unless assoc.member_end_type
-            next unless assoc.member_end_type == "inheritance"
+        parent_qname = resolve_qualified_name(parent_name, package_path)
+        return unless parent_qname && child_qname != parent_qname
 
-            parent_name = assoc.member_end
-            next unless parent_name
+        (@inheritance_graph[parent_qname] ||= []) << child_qname
+      end
 
-            parent_name = parent_name.name if parent_name.is_a?(Lutaml::Uml::Generalization)
-            next unless parent_name.is_a?(String) && !parent_name.empty?
+      def index_inheritance_assoc_edges(child_qname, klass, package_path)
+        return unless klass.associations
 
-            parent_qname = resolve_qualified_name(parent_name, package_path)
-            next unless parent_qname
-            next if child_qname == parent_qname
+        klass.associations.each do |assoc|
+          next unless assoc.member_end_type == "inheritance"
 
-            @inheritance_graph[parent_qname] ||= []
-            @inheritance_graph[parent_qname] << child_qname
-          end
+          parent_name = assoc.member_end
+          next unless parent_name
+
+          parent_name = parent_name.name if parent_name.is_a?(Lutaml::Uml::Generalization)
+          next unless parent_name.is_a?(String) && !parent_name.empty?
+
+          parent_qname = resolve_qualified_name(parent_name, package_path)
+          next unless parent_qname && child_qname != parent_qname
+
+          (@inheritance_graph[parent_qname] ||= []) << child_qname
         end
       end
 
@@ -97,22 +104,10 @@ module Lutaml
       # @param generalization [Lutaml::Uml::Generalization]
       # Generalization object
       # @return [String, nil] Parent class name
-      def extract_parent_name(generalization) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+      def extract_parent_name(generalization)
         return nil unless generalization
 
-        # Check for general attribute (could be a string or object)
-        if generalization.general
-          parent = generalization.general
-          return parent.name if parent
-          return parent.to_s if parent
-        end
-
-        # Check for name attribute directly
-        if generalization.name
-          return generalization.name
-        end
-
-        nil
+        name_from_general(generalization) || generalization.name
       end
 
       # Resolve a class name to its qualified name
@@ -124,6 +119,13 @@ module Lutaml
       # @param name [String] Class name to resolve
       # @param current_package_path [String] Current package context
       # @return [String, nil] Resolved qualified name
+      def name_from_general(generalization)
+        parent = generalization.general
+        return nil unless parent
+
+        parent.respond_to?(:name) ? parent.name : parent.to_s
+      end
+
       def resolve_qualified_name(name, current_package_path)
         # If name contains "::", it might already be qualified
         return name if @qualified_names.key?(name)