lutaml 0.10.13 → 0.10.14

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,39 +63,36 @@ 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?
 
-          # 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

data/lib/lutaml/uml_repository/queries/class_query.rb

@@ -66,7 +66,7 @@ module Lutaml
         # @example Recursive query
         #   classes = query.in_package("ModelRoot::i-UR", recursive: true)
         #   # Returns classes in i-UR and all nested packages
-        def in_package(package_path_string, recursive: false) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        def in_package(package_path_string, recursive: false)
           return [] if package_path_string.nil? || package_path_string.empty?
 
           pkg_to_classes = indexes[:package_to_classes]
@@ -81,69 +81,95 @@ module Lutaml
         private
 
         # O(1) indexed lookup for in_package
-        def in_package_indexed(package_path_string, pkg_to_classes, recursive:) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def in_package_indexed(package_path_string, pkg_to_classes, recursive:)
           is_absolute = package_path_string.start_with?("::")
           search_segs = package_path_string.split("::").reject(&:empty?)
 
           results = []
           pkg_to_classes.each do |path, classes|
-            path_segs = path.split("::")
-            matched = if is_absolute
-                        if recursive
-                          path == package_path_string ||
-                            path.start_with?("#{package_path_string}::")
-                        else
-                          path == package_path_string
-                        end
-                      elsif recursive
-                        # Relative: match when path ends with search segments
-                        (0..(path_segs.size - search_segs.size)).any? do |i|
-                          path_segs[i, search_segs.size] == search_segs
-                        end
-                      else
-                        path_segs.size >= search_segs.size &&
-                          path_segs[-search_segs.size..] == search_segs
-                      end
-
-            results.concat(classes) if matched
+            results.concat(classes) if indexed_path_matches?(
+              path, package_path_string, is_absolute, search_segs, recursive
+            )
           end
           results
         end
 
+        def indexed_path_matches?(path, package_path_string, is_absolute,
+                                  search_segs, recursive)
+          if is_absolute
+            indexed_absolute_match?(path, package_path_string, recursive)
+          else
+            indexed_relative_match?(path.split("::"), search_segs, recursive)
+          end
+        end
+
+        def indexed_absolute_match?(path, package_path_string, recursive)
+          if recursive
+            path == package_path_string ||
+              path.start_with?("#{package_path_string}::")
+          else
+            path == package_path_string
+          end
+        end
+
+        def indexed_relative_match?(path_segs, search_segs, recursive)
+          if recursive
+            (0..(path_segs.size - search_segs.size)).any? do |i|
+              path_segs[i, search_segs.size] == search_segs
+            end
+          else
+            path_segs.size >= search_segs.size &&
+              path_segs[-search_segs.size..] == search_segs
+          end
+        end
+
         # Fallback: original O(n) scan
         def in_package_scan(package_path_string, recursive:)
           package_path = Lutaml::Uml::PackagePath.new(package_path_string)
-          results = []
           is_absolute = package_path.absolute?
 
-          indexes[:qualified_names].each do |qname_string, klass|
-            qname = Lutaml::Uml::QualifiedName.new(qname_string)
-
-            matched = if is_absolute
-                        if recursive
-                          qname.package_path.starts_with?(package_path)
-                        else
-                          qname.package_path == package_path
-                        end
-                      else
-                        class_pkg_segs = qname.package_path.segments
-                        search_segs = package_path.segments
-
-                        if recursive
-                          (0..(class_pkg_segs.size - search_segs.size))
-                            .any? do |i|
-                            class_pkg_segs[i, search_segs.size] == search_segs
-                          end
-                        else
-                          class_pkg_segs.size >= search_segs.size &&
-                            class_pkg_segs[-search_segs.size..] == search_segs
-                        end
-                      end
-
-            results << klass if matched
+          indexes[:qualified_names].each_value.select do |klass|
+            scan_matches_package?(klass, package_path, is_absolute, recursive)
           end
+        end
 
-          results
+        def scan_matches_package?(klass, package_path, is_absolute, recursive)
+          qname = resolve_qname_for(klass)
+          return false unless qname
+
+          if is_absolute
+            match_absolute_path?(qname, package_path, recursive)
+          else
+            match_relative_path?(qname, package_path, recursive)
+          end
+        end
+
+        def resolve_qname_for(klass)
+          indexes[:qualified_names].find { |_, v| v == klass }&.first
+        end
+
+        def match_absolute_path?(qname, package_path, recursive)
+          qname = Lutaml::Uml::QualifiedName.new(qname)
+          if recursive
+            qname.package_path.starts_with?(package_path)
+          else
+            qname.package_path == package_path
+          end
+        end
+
+        def match_relative_path?(qname_string, package_path, recursive)
+          qname = Lutaml::Uml::QualifiedName.new(qname_string)
+          class_pkg_segs = qname.package_path.segments
+          search_segs = package_path.segments
+
+          if recursive
+            (0..(class_pkg_segs.size - search_segs.size)).any? do |i|
+              class_pkg_segs[i, search_segs.size] == search_segs
+            end
+          else
+            class_pkg_segs.size >= search_segs.size &&
+              class_pkg_segs[-search_segs.size..] == search_segs
+          end
         end
       end
     end

data/lib/lutaml/uml_repository/queries/inheritance_query.rb

@@ -33,27 +33,15 @@ module Lutaml
         #   parent = query.supertype("ModelRoot::Child")
         #   # Or
         #   parent = query.supertype(child_class)
-        def supertype(class_or_qname) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        def supertype(class_or_qname)
           klass = resolve_class(class_or_qname)
-          return nil unless klass
-          return nil unless klass.is_a?(Lutaml::Uml::Class)
-          return nil unless klass.generalization
+          return nil unless valid_supertype_target?(klass)
 
           parent_name = extract_parent_name(klass.generalization)
           return nil unless parent_name
-          # avoid self-references
           return nil if parent_name == klass.name
 
-          # Try to find in qualified_names index
-          qname_string = resolve_qname(class_or_qname)
-          return nil unless qname_string
-
-          qname = Lutaml::Uml::QualifiedName.new(qname_string)
-          package_path = qname.package_path.to_s
-
-          # Try to resolve parent qualified name
-          parent_qname = resolve_parent_qualified_name(parent_name,
-                                                       package_path)
+          parent_qname = resolve_parent_qname(class_or_qname, parent_name)
           return nil unless parent_qname
 
           indexes[:qualified_names][parent_qname]
@@ -200,14 +188,8 @@ module Lutaml
         #   qualified name, or xmi_id
         # @return [Boolean] true if circular inheritance detected
         def has_circular_inheritance?(class_or_id, visited: Set.new)
-          qname = if class_or_id.is_a?(String) &&
-              indexes[:qualified_names].key?(class_or_id)
-                    class_or_id
-                  else
-                    resolve_qname(class_or_id)
-                  end
+          qname = resolve_to_qname(class_or_id)
           return false unless qname
-
           return true if visited.include?(qname)
 
           visited.add(qname)
@@ -219,6 +201,21 @@ module Lutaml
 
         private
 
+        def valid_supertype_target?(klass)
+          return false unless klass
+          return false unless klass.is_a?(Lutaml::Uml::Class)
+
+          klass.generalization ? true : false
+        end
+
+        def resolve_parent_qname(class_or_qname, parent_name)
+          qname_string = resolve_qname(class_or_qname)
+          return nil unless qname_string
+
+          qname = Lutaml::Uml::QualifiedName.new(qname_string)
+          resolve_parent_qualified_name(parent_name, qname.package_path.to_s)
+        end
+
         # Resolve a class by xmi_id or qualified name
         #
         # @param class_or_id [String] Qualified name or xmi_id
@@ -257,22 +254,24 @@ module Lutaml
         # @param max_depth [Integer, nil] Maximum depth to traverse
         # @param current_depth [Integer] Current depth
         # @return [Array] Array of descendant class objects
-        def collect_descendants(qname_string, max_depth, current_depth) # rubocop:disable Metrics/MethodLength
+        def collect_descendants(qname_string, max_depth, current_depth)
           return [] if max_depth && current_depth >= max_depth
 
           children = direct_subtypes(qname_string)
           result = children.dup
+          collect_child_descendants(children, max_depth, current_depth, result)
+          result
+        end
 
+        def collect_child_descendants(children, max_depth, current_depth,
+result)
           children.each do |child|
             child_qname = resolve_qname(child)
             next unless child_qname
 
-            grandchildren = collect_descendants(child_qname, max_depth,
-                                                current_depth + 1)
-            result.concat(grandchildren)
+            result.concat(collect_descendants(child_qname, max_depth,
+                                              current_depth + 1))
           end
-
-          result
         end
 
         # Extract parent name from generalization object
@@ -285,13 +284,24 @@ module Lutaml
           return nil unless generalization.is_a?(Lutaml::Uml::Generalization)
 
           parent = generalization.general
-          if parent
-            return parent.name if parent.is_a?(Lutaml::Uml::Generalization) && parent.name
+          return extract_name_from_parent(parent) if parent
+
+          generalization.name if generalization.name
+        end
 
-            return parent.to_s
+        def resolve_to_qname(class_or_id)
+          if class_or_id.is_a?(String) &&
+              indexes[:qualified_names].key?(class_or_id)
+            class_or_id
+          else
+            resolve_qname(class_or_id)
           end
+        end
 
-          generalization.name if generalization.name
+        def extract_name_from_parent(parent)
+          return parent.name if parent.is_a?(Lutaml::Uml::Generalization) && parent.name
+
+          parent.to_s
         end
 
         # Resolve a class name to its qualified name

data/lib/lutaml/uml_repository/static_site/data_transformer.rb

@@ -33,24 +33,13 @@ module Lutaml
         def transform
           Models::SpaDocument.new(
             metadata: Serializers::MetadataBuilder.new(repository).build,
-            package_tree: Serializers::PackageTreeBuilder.new(repository,
-                                                              id_generator).build,
-            packages: Serializers::PackageSerializer.new(repository,
-                                                         id_generator, options).build_map,
-            classes: Serializers::ClassSerializer.new(repository, id_generator,
-                                                      options, inheritance_resolver).build_map,
-            attributes: Serializers::AttributeSerializer.new(repository,
-                                                             id_generator, options).build_map,
+            package_tree: build_package_tree,
+            packages: build_packages_map,
+            classes: build_classes_map,
+            attributes: build_attributes_map,
             associations: build_associations_map,
-            operations: Serializers::OperationSerializer.new(repository,
-                                                             id_generator).build_map,
-            diagrams: if options[:include_diagrams]
-                        Serializers::DiagramSerializer.new(
-                          repository, id_generator, options
-                        ).build_map
-                      else
-                        {}
-                      end,
+            operations: build_operations_map,
+            diagrams: build_diagrams_map,
           )
         end
 
@@ -74,24 +63,7 @@ module Lutaml
           map = Hash.new { |h, k| h[k] = [] }
 
           repository.classes_index.each do |klass|
-            next unless klass.association_generalization
-            unless klass.association_generalization && !klass.association_generalization.empty?
-              next
-            end
-
-            klass.association_generalization.each do |assoc_gen|
-              parent_object_id = assoc_gen.parent_object_id
-              next unless parent_object_id
-
-              parent_class = class_lookup.by_object_id(parent_object_id)
-              if parent_class&.xmi_id
-                next if parent_class.xmi_id == klass.xmi_id
-
-                unless map[klass.xmi_id].include?(parent_class.xmi_id)
-                  map[klass.xmi_id] << parent_class.xmi_id
-                end
-              end
-            end
+            add_generalization_entries(map, klass)
           end
 
           map
@@ -101,6 +73,54 @@ module Lutaml
           @class_lookup ||= ClassLookupIndex.new(repository.classes_index)
         end
 
+        def build_package_tree
+          Serializers::PackageTreeBuilder.new(repository, id_generator).build
+        end
+
+        def build_packages_map
+          Serializers::PackageSerializer.new(repository, id_generator,
+                                             options).build_map
+        end
+
+        def build_classes_map
+          Serializers::ClassSerializer.new(repository, id_generator,
+                                           options, inheritance_resolver).build_map
+        end
+
+        def build_attributes_map
+          Serializers::AttributeSerializer.new(repository, id_generator,
+                                               options).build_map
+        end
+
+        def build_operations_map
+          Serializers::OperationSerializer.new(repository,
+                                               id_generator).build_map
+        end
+
+        def build_diagrams_map
+          return {} unless options[:include_diagrams]
+
+          Serializers::DiagramSerializer.new(repository, id_generator,
+                                             options).build_map
+        end
+
+        def add_generalization_entries(map, klass)
+          return unless klass.association_generalization
+          return if klass.association_generalization.empty?
+
+          klass.association_generalization.each do |assoc_gen|
+            parent_object_id = assoc_gen.parent_object_id
+            next unless parent_object_id
+
+            parent_class = class_lookup.by_object_id(parent_object_id)
+            next unless parent_class&.xmi_id
+            next if parent_class.xmi_id == klass.xmi_id
+            next if map[klass.xmi_id].include?(parent_class.xmi_id)
+
+            map[klass.xmi_id] << parent_class.xmi_id
+          end
+        end
+
         def format_definition(definition)
           return nil if definition.nil? || definition.empty?
 

data/lib/lutaml/uml_repository/static_site/search_index_builder.rb

@@ -51,23 +51,9 @@ module Lutaml
 
         def build_document_store
           documents = []
-
-          repository.classes_index.each do |klass|
-            documents << build_class_document(klass)
-
-            klass.attributes&.each do |attr|
-              documents << build_attribute_document(attr, klass)
-            end
-          end
-
-          repository.associations_index.each do |assoc|
-            documents << build_association_document(assoc)
-          end
-
-          repository.packages_index.each do |package|
-            documents << build_package_document(package)
-          end
-
+          documents.concat(build_class_documents)
+          documents.concat(build_association_documents)
+          documents.concat(build_package_documents)
           documents
         end
 
@@ -135,8 +121,8 @@ module Lutaml
             class_type(klass),
             Array(klass.stereotype).join(" "),
             klass.definition,
-            klass.attributes&.map(&:name)&.join(" "),
-            klass.operations&.map(&:name)&.join(" "),
+            collect_names(klass.attributes),
+            collect_names(klass.operations),
           ].compact
 
           normalize_content(parts.join(" "))
@@ -186,6 +172,33 @@ module Lutaml
           all_content.join(" ").gsub(/\s+/, " ").strip
         end
 
+        def build_class_documents
+          docs = []
+          repository.classes_index.each do |klass|
+            docs << build_class_document(klass)
+            klass.attributes&.each do |attr|
+              docs << build_attribute_document(attr, klass)
+            end
+          end
+          docs
+        end
+
+        def build_association_documents
+          repository.associations_index.map do |assoc|
+            build_association_document(assoc)
+          end
+        end
+
+        def build_package_documents
+          repository.packages_index.map do |package|
+            build_package_document(package)
+          end
+        end
+
+        def collect_names(items)
+          items&.map(&:name)&.join(" ")
+        end
+
         def class_type(klass)
           klass.class.name.split("::").last
         end

data/lib/lutaml/uml_repository/static_site/serializers/class_serializer.rb

@@ -30,10 +30,7 @@ inheritance_resolver)
 
           private
 
-          def serialize(klass, id) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-            class_associations = find_class_associations(klass)
-            sorted_associations = sort_associations(class_associations, klass)
-
+          def serialize(klass, id)
             Models::SpaClass.new(
               id: id,
               xmi_id: klass.xmi_id,
@@ -43,10 +40,10 @@ inheritance_resolver)
               package: package_id_for_class(klass),
               stereotypes: normalize_stereotypes(klass.stereotype),
               definition: format_definition(klass.definition),
-              attributes: (klass.attributes || []).sort_by { |a| a.name || "" }
-                .map { |attr| @id_generator.attribute_id(attr, klass) },
+              attributes: serialize_attribute_ids(klass),
               operations: serialize_class_operations(klass),
-              associations: sorted_associations,
+              associations: sort_associations(find_class_associations(klass),
+                                              klass),
               generalizations: @inheritance_resolver.find_generalizations(klass),
               specializations: @inheritance_resolver.find_specializations(klass),
               is_abstract: klass.is_abstract,
@@ -56,6 +53,11 @@ inheritance_resolver)
             )
           end
 
+          def serialize_attribute_ids(klass)
+            (klass.attributes || []).sort_by { |a| a.name || "" }
+              .map { |attr| @id_generator.attribute_id(attr, klass) }
+          end
+
           def find_class_associations(klass)
             associations = @repository.associations_of(klass)
             associations.map { |assoc| @id_generator.association_id(assoc) }
@@ -65,18 +67,26 @@ inheritance_resolver)
 
           def sort_associations(assoc_ids, klass)
             assoc_ids.sort_by do |assoc_id|
-              assoc = @repository.associations_index.find do |a|
-                @id_generator.association_id(a) == assoc_id
-              end
+              assoc = find_assoc_by_id(assoc_id)
               next "" unless assoc
 
-              if assoc.owner_end_xmi_id == klass.xmi_id
-                assoc.owner_end_attribute_name || assoc.owner_end || ""
-              elsif assoc.member_end_xmi_id == klass.xmi_id
-                assoc.member_end_attribute_name || assoc.member_end || ""
-              else
-                ""
-              end
+              resolve_assoc_role(assoc, klass)
+            end
+          end
+
+          def find_assoc_by_id(assoc_id)
+            @repository.associations_index.find do |a|
+              @id_generator.association_id(a) == assoc_id
+            end
+          end
+
+          def resolve_assoc_role(assoc, klass)
+            if assoc.owner_end_xmi_id == klass.xmi_id
+              assoc.owner_end_attribute_name || assoc.owner_end || ""
+            elsif assoc.member_end_xmi_id == klass.xmi_id
+              assoc.member_end_attribute_name || assoc.member_end || ""
+            else
+              ""
             end
           end