lutaml 0.10.19 → 0.11.2

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

@@ -1,236 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module Queries
-      class SearchQuery < BaseQuery
-        include Lutaml::Uml::ModelHelpers
-
-        RESULT_KEYS = {
-          class: :classes,
-          attribute: :attributes,
-          association: :associations,
-        }.freeze
-
-        FIELD_READERS = {
-          name: lambda(&:name),
-          documentation: lambda(&:documentation),
-          owner_end: lambda(&:owner_end),
-          member_end: lambda(&:member_end),
-          owner_end_attribute_name: lambda(&:owner_end_attribute_name),
-          member_end_attribute_name: lambda(&:member_end_attribute_name),
-        }.freeze
-
-        def search(query_string, types: %i[class attribute association],
-                          fields: [:name], case_sensitive: false)
-          return empty_result if query_string.nil? || query_string.empty?
-
-          results = { classes: [], attributes: [], associations: [] }
-          types.each do |type|
-            key = RESULT_KEYS[type]
-            results[key] = dispatch_search(
-              type, query_string,
-              fields: fields, case_sensitive: case_sensitive
-            )
-          end
-          results[:total] =
-            results.values_at(:classes, :attributes, :associations).sum(&:size)
-          results
-        end
-
-        def full_text_search(query_string, fields: [:name],
-case_sensitive: false)
-          results = { classes: [], packages: [], total: 0 }
-          return results if query_string.nil? || query_string.empty?
-
-          results[:classes] = search_classes(
-            query_string, fields: fields, case_sensitive: case_sensitive
-          )
-          results[:packages] = search_packages(
-            query_string, case_sensitive: case_sensitive
-          )
-          results[:total] = results[:classes].size + results[:packages].size
-          results
-        end
-
-        def search_classes(query, fields: %i[name documentation],
-                                case_sensitive: false)
-          pattern = pattern_from(query, case_sensitive)
-
-          indexes[:qualified_names].filter_map do |qname, entity|
-            next unless entity.is_a?(Lutaml::Uml::Class)
-
-            match_field = first_matching_field(entity, fields, pattern)
-            next unless match_field
-
-            build_search_result(entity, :class, qname, match_field)
-          end.uniq
-        end
-
-        def search_attributes(query, fields: [:name],
-                                     case_sensitive: false)
-          pattern = pattern_from(query, case_sensitive)
-
-          indexes[:qualified_names].filter_map do |class_qname, entity|
-            next unless entity.is_a?(Lutaml::Uml::Classifier) && entity.attributes
-
-            attr_match = find_matching_attribute(entity, fields, pattern)
-            next unless attr_match
-
-            attr, match_field = attr_match
-            build_search_result(
-              attr, :attribute,
-              "#{class_qname}::#{attr.name}", match_field,
-              { "class_name" => entity.name, "class_qname" => class_qname },
-              package_path: extract_package_path(class_qname)
-            )
-          end.uniq
-        end
-
-        def search_associations(query,
-                                fields: %i[
-                                  name owner_end member_end
-                                  owner_end_attribute_name
-                                  member_end_attribute_name documentation
-                                ],
-                                case_sensitive: false)
-          pattern = pattern_from(query, case_sensitive)
-
-          get_all_associations.filter_map do |assoc|
-            match_field = first_matching_field(assoc, fields, pattern)
-            next unless match_field
-
-            build_search_result(
-              assoc, :association,
-              assoc.name || "(unnamed)", match_field,
-              { "source" => assoc.owner_end, "target" => assoc.member_end }
-            )
-          end.uniq
-        end
-
-        def search_by_stereotype(query, case_sensitive: false)
-          pattern = pattern_from(query, case_sensitive)
-
-          find_entities_by_stereotype_pattern(pattern).map do |entity|
-            build_search_result(
-              entity,
-              entity.class.name.split("::").last.downcase.to_sym,
-              "", :stereotype
-            )
-          end
-        end
-
-        def search_packages(query, case_sensitive: false)
-          pattern = pattern_from(query, case_sensitive)
-
-          indexes[:package_paths].filter_map do |path_string, package|
-            next unless path_string.to_s.match?(pattern)
-
-            build_search_result(package, :package, path_string, :package_path,
-                                package_path: path_string)
-          end
-        end
-
-        def get_all_associations
-          all_associations = []
-
-          if document.is_a?(Lutaml::Uml::Document) && document.associations
-            all_associations << document.associations
-          end
-
-          indexes[:qualified_names].each_value do |entity|
-            next unless classifiable_with_associations?(entity)
-
-            all_associations << entity.associations
-          end
-
-          all_associations.flatten.uniq
-        end
-
-        private
-
-        def pattern_from(query, case_sensitive)
-          query = query.gsub("*", ".*") unless query.include?(".*")
-          Regexp.new(query, case_sensitive ? 0 : Regexp::IGNORECASE)
-        end
-
-        def field_value_matches?(obj, field, pattern)
-          return false unless obj.class.attributes.key?(field)
-
-          read_attribute(obj, field)&.match?(pattern)
-        end
-
-        def first_matching_field(entity, fields, pattern)
-          fields.reverse_each.find do |f|
-            field_value_matches?(entity, f, pattern)
-          end
-        end
-
-        def find_matching_attribute(entity, fields, pattern)
-          result = nil
-          entity.attributes.each do |attr|
-            fields.each do |field|
-              result = [attr, field] if field_value_matches?(attr, field,
-                                                             pattern)
-            end
-          end
-          result
-        end
-
-        def build_search_result(entity, type, qname, match_field,
-                                context = {}, **extra)
-          SearchResult.new(
-            element: entity,
-            element_type: type,
-            qualified_name: qname,
-            package_path: extra[:package_path] || extract_package_path(qname),
-            match_field: match_field,
-            match_context: context,
-          )
-        end
-
-        def classifiable_with_associations?(entity)
-          entity.is_a?(Lutaml::Uml::Class) || entity.is_a?(Lutaml::Uml::DataType)
-        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
-
-        def empty_result
-          { classes: [], attributes: [], associations: [], total: 0 }
-        end
-
-        def dispatch_search(type, query_string, fields:, case_sensitive:)
-          case type
-          when :class
-            search_classes(query_string,
-                           fields: fields,
-                           case_sensitive: case_sensitive)
-          when :attribute
-            search_attributes(query_string,
-                              fields: fields,
-                              case_sensitive: case_sensitive)
-          when :association
-            search_associations(query_string,
-                                fields: fields,
-                                case_sensitive: case_sensitive)
-          end
-        end
-
-        def read_attribute(obj, field)
-          reader = FIELD_READERS[field]
-          return nil unless reader
-
-          reader.call(obj)
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module QueryDSL
-      module Conditions
-        # Base class for query conditions
-        #
-        # Provides the interface for filtering results in query operations.
-        # All concrete condition classes must implement the {#apply} method.
-        #
-        # @abstract Subclass and override {#apply} to implement a custom
-        #   condition
-        class BaseCondition
-          # Apply the condition to filter results
-          #
-          # @param results [Array] The collection to filter
-          # @return [Array] The filtered collection
-          # @raise [NotImplementedError] if not implemented by subclass
-          def apply(results)
-            raise NotImplementedError,
-                  "#{self.class} must implement #apply"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module QueryDSL
-      module Conditions
-        # Block-based condition for custom filtering logic
-        #
-        # Allows arbitrary filtering logic to be specified using a Ruby block.
-        # The block receives each object and should return true/false.
-        #
-        # @example Filter by attribute count
-        #   condition = BlockCondition.new { |c| c.attributes.size > 10 }
-        #   filtered = condition.apply(classes)
-        #
-        # @example Complex filtering
-        #   condition = BlockCondition.new do |c|
-        #     c.attributes.any? && c.associations.empty?
-        #   end
-        #   filtered = condition.apply(classes)
-        class BlockCondition < BaseCondition
-          # Initialize with a filtering block
-          #
-          # @param block [Proc] The block to use for filtering
-          # @raise [ArgumentError] if no block provided
-          def initialize(&block)
-            super()
-            raise ArgumentError, "Block required" unless block
-
-            @block = block
-          end
-
-          # Apply block-based filtering to results
-          #
-          # @param results [Array] The collection to filter
-          # @return [Array] Objects for which block returns true
-          def apply(results)
-            results.select(&@block)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module QueryDSL
-      module Conditions
-        # Hash-based condition for filtering query results
-        #
-        # Filters results based on attribute-value pairs specified in a hash.
-        # All conditions must match for an object to be included in results.
-        #
-        # @example Filter by stereotype
-        #   condition = HashCondition.new(stereotype: 'featureType')
-        #   filtered = condition.apply(classes)
-        #
-        # @example Multiple conditions
-        #   condition = HashCondition.new(
-        #     stereotype: 'featureType',
-        #     is_abstract: false
-        #   )
-        #   filtered = condition.apply(classes)
-        class HashCondition < BaseCondition
-          # Initialize with hash conditions
-          #
-          # @param conditions [Hash] Attribute-value pairs to match
-          def initialize(conditions)
-            super()
-            @conditions = conditions
-          end
-
-          # Apply hash-based filtering to results
-          #
-          # @param results [Array] The collection to filter
-          # @return [Array] Objects matching all conditions
-          def apply(results)
-            results.select do |obj|
-              @conditions.all? do |key, value|
-                matches_condition?(obj, key, value)
-              end
-            end
-          end
-
-          private
-
-          # Check if object matches a single condition
-          #
-          # @param obj [Object] The object to check
-          # @param key [Symbol, String] The attribute name
-          # @param value [Object] The expected value
-          # @return [Boolean] true if condition matches
-          def matches_condition?(obj, key, value)
-            return false unless obj.class.attributes.key?(key.to_sym)
-
-            actual_value = obj.public_send(key)
-            compare_values(actual_value, value)
-          end
-
-          # Compare actual and expected values
-          #
-          # @param actual [Object] The actual value from object
-          # @param expected [Object] The expected value
-          # @return [Boolean] true if values match
-          def compare_values(actual, expected) # rubocop:disable Metrics/MethodLength
-            case expected
-            when Regexp
-              expected.match?(actual.to_s)
-            when Proc
-              expected.call(actual)
-            else
-              # Handle array attributes (e.g., stereotype)
-              if actual.is_a?(Array)
-                actual.include?(expected)
-              else
-                actual == expected
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module QueryDSL
-      module Conditions
-        # Package-based condition for filtering by package membership
-        #
-        # Filters results based on package path, with support for
-        # recursive (descendant) matching.
-        #
-        # @example Filter by exact package
-        #   condition = PackageCondition.new(
-        #   "ModelRoot::i-UR", recursive: false)
-        #   filtered = condition.apply(classes)
-        #
-        # @example Filter by package and descendants
-        #   condition = PackageCondition.new("ModelRoot::i-UR", recursive: true)
-        #   filtered = condition.apply(classes)
-        class PackageCondition < BaseCondition
-          # Initialize with package path and recursion setting
-          #
-          # @param package_path [String, PackagePath]
-          # The package path to filter by
-          # @param recursive [Boolean] Whether to include descendants
-          def initialize(package_path, recursive: false)
-            super()
-            @package_path = if package_path.is_a?(PackagePath)
-                              package_path
-                            else
-                              PackagePath.new(package_path)
-                            end
-            @recursive = recursive
-          end
-
-          # Apply package-based filtering to results
-          #
-          # @param results [Array] The collection to filter
-          # @return [Array] Objects in the specified package
-          def apply(results)
-            results.select do |obj|
-              matches_package?(obj)
-            end
-          end
-
-          private
-
-          # Check if object matches package condition
-          #
-          # @param obj [Object] The object to check
-          # @return [Boolean] true if object is in target package
-          def matches_package?(obj)
-            obj_package_path = extract_package_path(obj)
-            return false unless obj_package_path
-
-            if @recursive
-              obj_package_path.starts_with?(@package_path)
-            else
-              obj_package_path == @package_path
-            end
-          end
-
-          # Extract package path from object
-          #
-          # @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 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
-
-          def coerce_package_path(path)
-            return nil unless path
-
-            path.is_a?(PackagePath) ? path : PackagePath.new(path)
-          rescue ArgumentError
-            nil
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/query_dsl/order.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module QueryDSL
-      # Order specification for sorting query results
-      #
-      # Sorts results based on a specified field and direction.
-      # Handles nil values by treating them as empty strings for comparison.
-      #
-      # @example Ascending order
-      #   order = Order.new(:name, :asc)
-      #   sorted = order.apply(classes)
-      #
-      # @example Descending order
-      #   order = Order.new(:name, :desc)
-      #   sorted = order.apply(classes)
-      class Order
-        VALID_DIRECTIONS = %i[asc desc].freeze
-
-        attr_reader :field, :direction
-
-        # Initialize with field and direction
-        #
-        # @param field [Symbol, String] The field to sort by
-        # @param direction [Symbol] The sort direction (:asc or :desc)
-        # @raise [ArgumentError] if direction is invalid
-        def initialize(field, direction = :asc)
-          @field = field.to_sym
-          @direction = validate_direction(direction)
-        end
-
-        # Apply ordering to results
-        #
-        # @param results [Array] The collection to sort
-        # @return [Array] The sorted collection
-        def apply(results)
-          sorted = results.sort_by do |obj|
-            extract_sort_value(obj)
-          end
-
-          @direction == :desc ? sorted.reverse : sorted
-        end
-
-        private
-
-        # Validate sort direction
-        #
-        # @param direction [Symbol] The direction to validate
-        # @return [Symbol] The validated direction
-        # @raise [ArgumentError] if direction is invalid
-        def validate_direction(direction)
-          dir = direction.to_sym
-          unless VALID_DIRECTIONS.include?(dir)
-            raise ArgumentError,
-                  "Invalid direction: #{direction}. " \
-                  "Must be one of #{VALID_DIRECTIONS.join(', ')}"
-          end
-          dir
-        end
-
-        # Extract sort value from object
-        #
-        # @param obj [Object] The object to extract value from
-        # @return [Object] The value to use for sorting
-        def extract_sort_value(obj)
-          return "" unless obj.class.attributes.key?(@field.to_sym)
-
-          value = obj.public_send(@field)
-          normalize_value(value)
-        end
-
-        # Normalize value for sorting
-        #
-        # @param value [Object] The value to normalize
-        # @return [Object] The normalized value
-        def normalize_value(value)
-          case value
-          when nil
-            ""
-          when String
-            value.downcase
-          else
-            value
-          end
-        end
-      end
-    end
-  end
-end