lutaml 0.10.13 → 0.10.15

data/lib/lutaml/qea/lookup_indexes.rb

@@ -15,34 +15,52 @@ module Lutaml
       #   instead of array
       # @return [Hash] Group index
       def build_group_index(collection, method, single: false)
-        if single
-          collection.each_with_object({}) do |item, hash|
-            key = item.public_send(method)
-            hash[key] = item if key
-          end
-        else
-          collection.each_with_object({}) do |item, hash|
-            key = item.public_send(method)
-            (hash[key] ||= []) << item if key
-          end
+        collection.each_with_object({}) do |item, hash|
+          key = item.public_send(method)
+          next unless key
+
+          single ? (hash[key] = item) : ((hash[key] ||= []) << item)
         end
       end
 
       # Eagerly build all lazy lookup indexes before freezing
       def build_lookup_indexes
+        build_primary_indexes
+        build_secondary_indexes
+      end
+
+      def build_primary_indexes
+        build_object_indexes
+        build_feature_indexes
+        build_connector_indexes
+        build_diagram_indexes
+      end
+
+      def build_object_indexes
         @objects_by_guid = build_group_index(objects, :ea_guid, single: true)
+        @objects_by_package_id = build_group_index(objects, :package_id)
+        @packages_by_parent = build_group_index(packages, :parent_id)
+      end
+
+      def build_feature_indexes
         @attributes_by_object_id = build_group_index(attributes, :ea_object_id)
         @operations_by_object_id = build_group_index(operations, :ea_object_id)
         @operation_params_by_id = build_group_index(operation_params,
                                                     :operationid)
+      end
+
+      def build_connector_indexes
         @connectors_by_start = build_group_index(connectors, :start_object_id)
         @connectors_by_end = build_group_index(connectors, :end_object_id)
-        @packages_by_parent = build_group_index(packages, :parent_id)
-        @objects_by_package_id = build_group_index(objects, :package_id)
+      end
+
+      def build_diagram_indexes
         @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/inheritance_walker.rb

@@ -36,13 +36,7 @@ module Lutaml
         ancestors = []
         @visited.clear
         collect_ancestors(klass, ancestors)
-        ancestors.reverse_each.with_index(1) do |ancestor, level|
-          break if @visited.include?(ancestor.xmi_id)
-
-          @visited.add(ancestor.xmi_id)
-          yield(ancestor, level) if block_given?
-        end
-        ancestors.reverse_each.with_index(1)
+        yield_ancestors(ancestors)
       end
 
       # Get the direct supertype (immediate parent) of a class.
@@ -65,6 +59,16 @@ module Lutaml
 
       private
 
+      def yield_ancestors(ancestors)
+        ancestors.reverse_each.with_index(1) do |ancestor, level|
+          break if @visited.include?(ancestor.xmi_id)
+
+          @visited.add(ancestor.xmi_id)
+          yield(ancestor, level) if block_given?
+        end
+        ancestors.reverse_each.with_index(1)
+      end
+
       # Collect ancestors recursively into the result array.
       # Uses a trail set for cycle detection (avoids Set mutation issues across calls).
       def collect_ancestors(klass, result, trail = [])

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/exporters/markdown/index_page_builder.rb

@@ -54,16 +54,24 @@ module Lutaml
             indent = "  " * depth
             path = node[:path]
             link = @link_resolver.package_link(path)
-            result = "#{indent}- [#{node[:name]}](#{link})"
-            result += " (#{node[:classes_count]} classes)" if node[:classes_count].positive?
-            result += "\n"
-
-            if node[:children]&.any?
-              node[:children].each do |child|
-                result += build_tree_node(child, depth + 1)
-              end
-            end
+            result = format_tree_line(indent, node[:name], link,
+                                      node[:classes_count])
+
+            append_child_nodes(result, node[:children], depth)
+          end
 
+          def format_tree_line(indent, name, link, classes_count)
+            line = "#{indent}- [#{name}](#{link})"
+            line += " (#{classes_count} classes)" if classes_count&.positive?
+            "#{line}\n"
+          end
+
+          def append_child_nodes(result, children, depth)
+            return result unless children&.any?
+
+            children.each do |child|
+              result << build_tree_node(child, depth + 1)
+            end
             result
           end
         end

data/lib/lutaml/uml_repository/exporters/markdown_exporter.rb

@@ -54,32 +54,39 @@ module Lutaml
           )
 
           builder = Markdown::PackagePageBuilder.new(repository, link_resolver)
-          packages.each do |package|
-            path = link_resolver.package_path(package)
-            content = builder.build(package, path)
-            filename = link_resolver.sanitize_filename("#{path}.md")
-            File.write(File.join(output_dir, "packages", filename), content)
-          end
+          packages.each { |pkg| write_package_page(builder, pkg) }
         end
 
-        def generate_class_pages
-          classes = if options[:package]
-                      repository.classes_in_package(
-                        options[:package],
-                        recursive: options.fetch(:recursive, true),
-                      )
-                    else
-                      indexes&.dig(:classes)&.values || []
-                    end
+        def write_package_page(builder, package)
+          path = link_resolver.package_path(package)
+          content = builder.build(package, path)
+          filename = link_resolver.sanitize_filename("#{path}.md")
+          File.write(File.join(output_dir, "packages", filename), content)
+        end
 
+        def generate_class_pages
+          classes = collect_export_classes
           builder = Markdown::ClassPageBuilder.new(repository, link_resolver)
-          classes.each do |klass|
-            qname = link_resolver.qualified_name(klass)
-            content = builder.build(klass, qname)
-            filename = link_resolver.sanitize_filename("#{qname}.md")
-            File.write(File.join(output_dir, "classes", filename), content)
+          classes.each { |klass| write_class_page(builder, klass) }
+        end
+
+        def collect_export_classes
+          if options[:package]
+            repository.classes_in_package(
+              options[:package],
+              recursive: options.fetch(:recursive, true),
+            )
+          else
+            indexes&.dig(:classes)&.values || []
           end
         end
+
+        def write_class_page(builder, klass)
+          qname = link_resolver.qualified_name(klass)
+          content = builder.build(klass, qname)
+          filename = link_resolver.sanitize_filename("#{qname}.md")
+          File.write(File.join(output_dir, "classes", filename), content)
+        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,70 +56,68 @@ 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
-
-          # Handle inheritance associations
-          next unless klass.associations
+      def index_generalization_edge(child_qname, klass, package_path)
+        return unless klass.generalization
 
-          klass.associations.each do |assoc|
-            next unless assoc.member_end_type
-            next unless assoc.member_end_type == "inheritance"
+        parent_name = extract_parent_name(klass.generalization)
+        return unless parent_name
 
-            parent_name = assoc.member_end
-            next unless parent_name
+        parent_qname = resolve_qualified_name(parent_name, package_path)
+        return unless parent_qname && child_qname != parent_qname
 
-            parent_name = parent_name.name if parent_name.is_a?(Lutaml::Uml::Generalization)
-            next unless parent_name.is_a?(String) && !parent_name.empty?
+        (@inheritance_graph[parent_qname] ||= []) << child_qname
+      end
 
-            parent_qname = resolve_qualified_name(parent_name, package_path)
-            next unless parent_qname
-            next if child_qname == parent_qname
+      def index_inheritance_assoc_edges(child_qname, klass, package_path)
+        return unless klass.associations
 
-            @inheritance_graph[parent_qname] ||= []
-            @inheritance_graph[parent_qname] << child_qname
-          end
+        klass.associations
+          .select { |assoc| assoc.member_end_type == "inheritance" }
+          .each do |assoc|
+          index_inheritance_edge(child_qname, assoc,
+                                 package_path)
         end
       end
 
+      def index_inheritance_edge(child_qname, assoc, package_path)
+        parent_name = resolve_parent_name_from_assoc(assoc)
+        return unless parent_name
+
+        parent_qname = resolve_qualified_name(parent_name, package_path)
+        return unless parent_qname && child_qname != parent_qname
+
+        (@inheritance_graph[parent_qname] ||= []) << child_qname
+      end
+
+      def resolve_parent_name_from_assoc(assoc)
+        parent_name = assoc.member_end
+        return nil unless parent_name
+
+        parent_name = parent_name.name if parent_name.is_a?(Lutaml::Uml::Generalization)
+        parent_name.is_a?(String) && !parent_name.empty? ? parent_name : nil
+      end
+
       # Extract parent name from generalization object
       #
       # @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 +129,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)

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

@@ -8,8 +8,12 @@ module Lutaml
       # Creates a hash mapping qualified names to Class/DataType/Enum objects:
       #   "ModelRoot::i-UR::urf::Building" => Class{}
       # @api public
-      def build_qualified_name_index # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-        # Index top-level classes, data_types, and enums from document
+      def build_qualified_name_index
+        index_document_classifiers
+        index_package_classifiers
+      end
+
+      def index_document_classifiers
         if @document.classes
           index_classifiers(@document.classes,
                             ROOT_PACKAGE_NAME)
@@ -19,8 +23,9 @@ module Lutaml
                             ROOT_PACKAGE_NAME)
         end
         index_classifiers(@document.enums, ROOT_PACKAGE_NAME) if @document.enums
+      end
 
-        # Traverse packages and index their classifiers
+      def index_package_classifiers
         traverse_packages(@document.packages,
                           parent_path: ROOT_PACKAGE_NAME) do |package, path|
           index_classifiers(package.classes, path) if package.classes
@@ -35,13 +40,18 @@ module Lutaml
       #   "featureType" => [Class{}, Class{}],
       #   "dataType" => [Class{}]
       # @api public
-      def build_stereotype_index # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
-        # Process top-level classes
+      def build_stereotype_index
+        index_document_stereotypes
+        index_package_stereotypes
+      end
+
+      def index_document_stereotypes
         index_by_stereotype(@document.classes) if @document.classes
         index_by_stereotype(@document.data_types) if @document.data_types
         index_by_stereotype(@document.enums) if @document.enums
+      end
 
-        # Process classes in packages
+      def index_package_stereotypes
         traverse_packages(@document.packages) do |package, _path|
           index_by_stereotype(package.classes) if package.classes
           index_by_stereotype(package.data_types) if package.data_types
@@ -53,42 +63,43 @@ module Lutaml
       #
       # @param classifiers [Array] Array of classifier objects
       # @param package_path [String] Package path for these classifiers
-      def index_classifiers(classifiers, package_path) # rubocop:disable Metrics/MethodLength
+      def index_classifiers(classifiers, package_path)
         return unless classifiers
 
         classifiers.each do |classifier|
           next unless classifier.name
 
-          qualified_name = "#{package_path}::#{classifier.name}"
-          @qualified_names[qualified_name] = classifier
-          if classifier.xmi_id
-            @class_to_qname[classifier.xmi_id] =
-              qualified_name
-          end
-          @classes[classifier.xmi_id] = classifier if classifier.xmi_id
-          @simple_name_to_qnames[classifier.name] ||= []
-          @simple_name_to_qnames[classifier.name] << qualified_name
-          (@package_to_classes[package_path] ||= []) << classifier
+          index_classifier(classifier, package_path)
         end
       end
 
+      def index_classifier(classifier, package_path)
+        qualified_name = "#{package_path}::#{classifier.name}"
+        @qualified_names[qualified_name] = classifier
+        @class_to_qname[classifier.xmi_id] = qualified_name if classifier.xmi_id
+        @classes[classifier.xmi_id] = classifier if classifier.xmi_id
+        (@simple_name_to_qnames[classifier.name] ||= []) << qualified_name
+        (@package_to_classes[package_path] ||= []) << classifier
+      end
+
       # Index classifiers by their stereotypes
       #
       # @param classifiers [Array] Array of classifier objects
-      def index_by_stereotype(classifiers) # rubocop:disable Metrics/CyclomaticComplexity
+      def index_by_stereotype(classifiers)
         return unless classifiers
 
         classifiers.each do |classifier|
-          next unless classifier.stereotype && !classifier.stereotype.empty?
+          next unless has_stereotype?(classifier)
 
-          # Handle both String and Array stereotypes
-          stereotypes = Array(classifier.stereotype)
-          stereotypes.each do |stereotype|
-            @stereotypes[stereotype] ||= []
-            @stereotypes[stereotype] << classifier
+          Array(classifier.stereotype).each do |stereotype|
+            (@stereotypes[stereotype] ||= []) << classifier
           end
         end
       end
+
+      def has_stereotype?(classifier)
+        classifier.stereotype && !classifier.stereotype.empty?
+      end
     end
   end
 end