lutaml 0.10.13 → 0.10.15

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,100 @@ 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
+            segments_overlap?(path_segs, search_segs)
+          else
+            segments_end_with?(path_segs, 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
+            segments_overlap?(class_pkg_segs, search_segs)
+          else
+            segments_end_with?(class_pkg_segs, search_segs)
+          end
+        end
+
+        def segments_overlap?(class_segs, search_segs)
+          (0..(class_segs.size - search_segs.size)).any? do |i|
+            class_segs[i, search_segs.size] == search_segs
+          end
+        end
+
+        def segments_end_with?(class_segs, search_segs)
+          class_segs.size >= search_segs.size &&
+            class_segs[-search_segs.size..] == search_segs
         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/queries/search_query.rb

@@ -113,7 +113,7 @@ module Lutaml
         # @param query [String] Query string
         # @param fields [Array<Symbol>] Fields to search in
         # @return [Array<SearchResult>] Matching search result objects
-        def search_classes( # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        def search_classes( # rubocop:disable Metrics/MethodLength
           query, fields: %i[name documentation],
           case_sensitive: false
         )
@@ -122,55 +122,64 @@ module Lutaml
           )
 
           indexes[:qualified_names].filter_map do |qname, entity|
-            match_field = nil
-            qualified_name = nil
-
             next unless entity.is_a?(Lutaml::Uml::Class)
 
-            # Check fields for match
-            fields.each do |field|
-              if entity.class.attributes.key?(field) &&
-                  entity.public_send(field)&.match?(pattern)
+            match_field = find_matching_field(entity, fields, pattern)
+            next unless match_field
 
-                match_field = field
-                qualified_name = qname
-              end
-            end
+            build_search_result(entity, :class, qname, match_field)
+          end.uniq
+        end
 
-            if match_field
-              SearchResult.new(
-                element: entity,
-                element_type: :class,
-                qualified_name: qualified_name,
-                package_path: extract_package_path(qualified_name),
-                match_field: match_field,
-              )
+        def find_matching_field(entity, fields, pattern)
+          last_match = nil
+          fields.each do |field|
+            if entity.class.attributes.key?(field) &&
+                entity.public_send(field)&.match?(pattern)
+              last_match = field
             end
-          end.uniq
+          end
+          last_match
         end
 
-        def search_by_stereotype(query, case_sensitive: false) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        def build_search_result(entity, type, qname, match_field, context = {})
+          SearchResult.new(
+            element: entity,
+            element_type: type,
+            qualified_name: qname,
+            package_path: extract_package_path(qname),
+            match_field: match_field,
+            match_context: context,
+          )
+        end
+
+        def search_by_stereotype(query, case_sensitive: false)
           pattern = regex_pattern_from_query(
             query, case_sensitive: case_sensitive
           )
 
-          matched_entities = indexes[:stereotypes]
+          matched_entities = find_entities_by_stereotype_pattern(pattern)
+          matched_entities.map { |entity| build_stereotype_result(entity) }
+        end
+
+        def find_entities_by_stereotype_pattern(pattern)
+          indexes[:stereotypes]
             .filter_map do |_stereotype, entities|
             entities.select do |entity|
               entity.is_a?(Lutaml::Uml::Classifier) &&
                 Array(entity.stereotype).any? { |s| s&.match?(pattern) }
             end.uniq
           end.uniq.flatten
+        end
 
-          matched_entities.map do |entity|
-            SearchResult.new(
-              element: entity,
-              element_type: entity.class.name.split("::").last.downcase,
-              qualified_name: "",
-              package_path: "",
-              match_field: :stereotype,
-            )
-          end
+        def build_stereotype_result(entity)
+          SearchResult.new(
+            element: entity,
+            element_type: entity.class.name.split("::").last.downcase,
+            qualified_name: "",
+            package_path: "",
+            match_field: :stereotype,
+          )
         end
 
         # Search for packages matching the query
@@ -212,61 +221,63 @@ module Lutaml
         # @param query [String] Query string
         # @param fields [Array<Symbol>] Fields to search in
         # @return [Array<Lutaml::Uml::Class>] Matching search result objects
-        def search_attributes(query, fields: [:name], case_sensitive: false) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        def search_attributes(query, fields: [:name], case_sensitive: false) # rubocop:disable Metrics/MethodLength
           pattern = regex_pattern_from_query(
             query, case_sensitive: case_sensitive
           )
 
-          indexes[:qualified_names].filter_map do |class_qname, entity| # rubocop:disable Metrics/BlockLength
+          indexes[:qualified_names].filter_map do |class_qname, entity|
             next unless entity.is_a?(Lutaml::Uml::Classifier) && entity.attributes
 
-            match_field = nil
-            match_attr = nil
-            qualified_name = nil
+            match_attr, match_field = find_matching_attribute(entity, fields,
+                                                              pattern)
+            next unless match_field
 
-            entity.attributes.each do |attr|
-              # Check attribute for match
-              fields.each do |field|
-                if attr.class.attributes.key?(field) &&
-                    attr.public_send(field)&.match?(pattern)
+            build_attribute_result(match_attr, entity, class_qname, match_field)
+          end.uniq
+        end
 
-                  match_attr = attr
-                  match_field = field
-                  qualified_name = class_qname
-                end
+        def find_matching_attribute(entity, fields, pattern)
+          match_attr = nil
+          match_field = nil
+          entity.attributes.each do |attr|
+            fields.each do |field|
+              if attr.class.attributes.key?(field) &&
+                  attr.public_send(field)&.match?(pattern)
+                match_attr = attr
+                match_field = field
               end
             end
+          end
+          match_field ? [match_attr, match_field] : nil
+        end
 
-            if match_field
-              SearchResult.new(
-                element: match_attr,
-                element_type: :attribute,
-                qualified_name: "#{qualified_name}::#{match_attr.name}",
-                package_path: extract_package_path(qualified_name),
-                match_field: match_field,
-                match_context: {
-                  "class_name" => entity&.name,
-                  "class_qname" => qualified_name,
-                },
-              )
-            end
-          end.uniq
+        def build_attribute_result(attr, entity, class_qname, match_field)
+          SearchResult.new(
+            element: attr,
+            element_type: :attribute,
+            qualified_name: "#{class_qname}::#{attr.name}",
+            package_path: extract_package_path(class_qname),
+            match_field: match_field,
+            match_context: {
+              "class_name" => entity.name,
+              "class_qname" => class_qname,
+            },
+          )
         end
 
         # Get all associations in the model
         #
         # @return [Array<Lutaml::Uml::Association>] All association objects
-        def get_all_associations # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        def get_all_associations
           all_associations = []
 
-          # Get all associations defined at document level and
           if document.is_a?(Lutaml::Uml::Document) && document.associations
             all_associations << document.associations
           end
 
-          # Get all associations defined within classes
           indexes[:qualified_names].each_value do |entity|
-            next unless (entity.is_a?(Lutaml::Uml::Class) || entity.is_a?(Lutaml::Uml::DataType)) && entity.associations
+            next unless classifiable_with_associations?(entity)
 
             all_associations << entity.associations
           end
@@ -274,12 +285,16 @@ module Lutaml
           all_associations.flatten.uniq
         end
 
+        def classifiable_with_associations?(entity)
+          (entity.is_a?(Lutaml::Uml::Class) || entity.is_a?(Lutaml::Uml::DataType)) && entity.associations
+        end
+
         # Search for associations matching the query
         #
         # @param query [String] Query string
         # @param fields [Array<Symbol>] Fields to search in
         # @return [Array<SearchResult>] Matching search result objects
-        def search_associations(query, # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        def search_associations(query, # rubocop:disable Metrics/MethodLength
           fields: %i[
             name owner_end member_end owner_end_attribute_name
             member_end_attribute_name documentation
@@ -291,27 +306,20 @@ module Lutaml
           )
 
           all_associations.filter_map do |assoc|
-            match_field = nil
+            match_field = find_matching_field(assoc, fields, pattern)
+            next unless match_field
 
-            fields.each do |field|
-              if assoc.class.attributes.key?(field) && assoc.public_send(field)&.match?(pattern)
-                match_field = field
-              end
-            end
-
-            if match_field
-              SearchResult.new(
-                element: assoc,
-                element_type: :association,
-                qualified_name: assoc.name || "(unnamed)",
-                package_path: "",
-                match_field: match_field,
-                match_context: {
-                  "source" => assoc.owner_end,
-                  "target" => assoc.member_end,
-                },
-              )
-            end
+            SearchResult.new(
+              element: assoc,
+              element_type: :association,
+              qualified_name: assoc.name || "(unnamed)",
+              package_path: "",
+              match_field: match_field,
+              match_context: {
+                "source" => assoc.owner_end,
+                "target" => assoc.member_end,
+              },
+            )
           end.uniq
         end
 

data/lib/lutaml/uml_repository/query_dsl/conditions/package_condition.rb

@@ -68,10 +68,17 @@ module Lutaml
           # @param obj [Object] The object to extract path from
           # @return [PackagePath, nil] The object's package path
           def extract_package_path(obj)
-            return nil unless obj.is_a?(Lutaml::Model::Serializable) &&
+            return nil unless serializable_with_path?(obj)
+
+            coerce_package_path(obj.package_path)
+          end
+
+          def serializable_with_path?(obj)
+            obj.is_a?(Lutaml::Model::Serializable) &&
               obj.class.attributes&.key?(:package_path)
+          end
 
-            path = obj.package_path
+          def coerce_package_path(path)
             return nil unless path
 
             path.is_a?(PackagePath) ? path : PackagePath.new(path)

data/lib/lutaml/uml_repository/repository/loader.rb

@@ -64,19 +64,26 @@ module Lutaml
         def self.from_file_cached(xmi_path, lur_path: nil)
           lur_path ||= xmi_path.sub(/\.xmi$/i, ".lur")
 
-          if File.exist?(lur_path) && File.mtime(lur_path) >= File.mtime(xmi_path)
+          if cache_valid?(lur_path, xmi_path)
             puts "Using cached LUR package: #{lur_path}" if $VERBOSE
             from_package(lur_path)
           else
-            puts "Building repository from XMI..." if $VERBOSE
-            repo = from_xmi(xmi_path)
-
-            puts "Caching as LUR package: #{lur_path}" if $VERBOSE
-            repo.export_to_package(lur_path)
-            repo
+            build_and_cache(xmi_path, lur_path)
           end
         end
 
+        def self.cache_valid?(lur_path, xmi_path)
+          File.exist?(lur_path) && File.mtime(lur_path) >= File.mtime(xmi_path)
+        end
+
+        def self.build_and_cache(xmi_path, lur_path)
+          puts "Building repository from XMI..." if $VERBOSE
+          repo = from_xmi(xmi_path)
+          puts "Caching as LUR package: #{lur_path}" if $VERBOSE
+          repo.export_to_package(lur_path)
+          repo
+        end
+
         # Load a Repository from a LUR package file.
         #
         # @param lur_path [String] Path to the .lur package file