lutaml 0.10.18 → 0.11.2

data/lib/lutaml/uml_repository/presenters/presenter_factory.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module Presenters
-      # Factory for creating appropriate presenter for UML elements.
-      #
-      # Uses a registry pattern to map element classes to presenter classes.
-      # Automatically selects the correct presenter based on element type.
-      #
-      # @example Creating a presenter
-      #   presenter = PresenterFactory.create(class_obj, repository)
-      #   puts presenter.to_text
-      class PresenterFactory
-        @presenters = {}
-
-        class << self
-          # Create appropriate presenter for the given element.
-          #
-          # @param element [Object] UML element to present
-          # @param repository [UmlRepository, nil] Optional repository context
-          # @param context [Hash, nil] Optional context hash for presenter
-          # @return [ElementPresenter] Appropriate presenter instance
-          # @raise [ArgumentError] if no presenter registered for element
-          #   type
-          def create(element, repository = nil, context = nil)
-            presenter_class = find_presenter_class(element)
-            presenter_class.new(element, repository, context)
-          end
-
-          # Register a presenter class for an element class.
-          #
-          # @param element_class [Class] The UML element class
-          # @param presenter_class [Class] The presenter class to use
-          def register(element_class, presenter_class)
-            @presenters[element_class] = presenter_class
-          end
-
-          # Get all registered presenters.
-          #
-          # @return [Hash] Map of element classes to presenter classes
-          def presenters
-            @presenters
-          end
-
-          private
-
-          # Find presenter class for element.
-          #
-          # Checks exact class match first, then inheritance chain.
-          #
-          # @param element [Object] Element to find presenter for
-          # @return [Class] Presenter class
-          # @raise [ArgumentError] if no presenter found
-          def find_presenter_class(element)
-            # Check exact class match
-            return @presenters[element.class] if
-              @presenters.key?(element.class)
-
-            # Check inheritance chain
-            element.class.ancestors.each do |ancestor|
-              return @presenters[ancestor] if @presenters.key?(ancestor)
-            end
-
-            # No presenter found
-            raise ArgumentError,
-                  "No presenter registered for #{element.class}. " \
-                  "Available: #{@presenters.keys.join(', ')}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module Queries
-      # Query service for association operations.
-      #
-      # Provides methods to find associations related to classes. Associations
-      # can be owned by classes or defined at the document level.
-      #
-      # @example Finding all associations for a class
-      #   query = AssociationQuery.new(document, indexes)
-      #   associations = query.find_for_class("ModelRoot::Building")
-      #
-      # @example Finding owned associations only
-      #   associations = query.find_for_class(klass, owned_only: true)
-      #
-      # @example Finding associations in a specific direction
-      #   associations = query.find_for_class(klass, direction: :source)
-      class AssociationQuery < BaseQuery
-        # Find associations for a specific class.
-        #
-        # @param class_or_qname [Lutaml::Uml::Class, String] The class object
-        #   or qualified name string
-        # @param options [Hash] Query options
-        # @option options [Boolean] :owned_only Return only associations owned
-        #   by the class (default: false)
-        # @option options [Boolean] :navigable_only Return only navigable
-        #   associations (default: false)
-        # @option options [Symbol] :direction Filter by direction - :source
-        #   (class is owner_end), :target (class is member_end), or :both
-        #   (default: :both)
-        # @return [Array<Lutaml::Uml::Association>] Array of association objects
-        # @example
-        #   # Get all associations
-        #   all = query.find_for_class("ModelRoot::Building")
-        #
-        #   # Get only owned associations
-        #   owned = query.find_for_class(
-        #   "ModelRoot::Building", owned_only: true)
-        #
-        #   # Get associations where class is the source
-        #   sources = query.find_for_class(
-        #   "ModelRoot::Building", direction: :source)
-        def find_for_class(class_or_qname, options = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          owned_only = options[:owned_only] || false
-          navigable_only = options[:navigable_only] || false
-          direction = options[:direction] || :both
-
-          klass = resolve_class(class_or_qname)
-          return [] unless klass
-
-          class_name = klass.name
-          results = []
-
-          # Get owned associations from the class itself
-          if (klass.is_a?(Lutaml::Uml::Class) || klass.is_a?(Lutaml::Uml::DataType)) && klass.associations
-            results.concat(klass.associations)
-          end
-
-          # Get associations from document level unless owned_only
-          if !owned_only &&
-              document.is_a?(Lutaml::Uml::Document) && document.associations
-            document_associations = document.associations.select do |assoc|
-              match_association?(assoc, class_name, direction)
-            end
-            results.concat(document_associations)
-          end
-
-          # Filter navigable if requested
-          if navigable_only
-            results.select! { |assoc| navigable?(assoc) }
-          end
-
-          results.uniq
-        end
-
-        # Find associations by their type.
-        #
-        # @param association_type [String] The type of association
-        #   (e.g., "aggregation", "composition", "association")
-        # @return [Array<Lutaml::Uml::Association>] Array of association objects
-        def find_by_type(association_type)
-          resolve_all_associations.select do |assoc|
-            assoc.member_end_type == association_type
-          end
-        end
-
-        def find_aggregations
-          find_by_type("aggregation")
-        end
-
-        def find_compositions
-          find_by_type("composition")
-        end
-
-        # Find associations between two classes
-        #
-        # @param owner_end_xmi_id [String] XMI ID of the owner end class
-        # @param member_end_xmi_id [String] XMI ID of the member end class
-        # @return [Array<Lutaml::Uml::Association>] Array of association objects
-        def find_between_classes(owner_end_xmi_id, member_end_xmi_id)
-          resolve_all_associations.select do |assoc|
-            assoc.owner_end_xmi_id == owner_end_xmi_id &&
-              assoc.member_end_xmi_id == member_end_xmi_id
-          end
-        end
-
-        # Retrieve all associations in the document
-        #
-        # @return [Array<Lutaml::Uml::Association>] Array of all associations
-        def all
-          resolve_all_associations
-        end
-
-        private
-
-        # Resolve all associations in the document
-        #
-        # @return [Array<Lutaml::Uml::Association>] Array of all associations
-        def resolve_all_associations
-          indexes[:qualified_names].values.filter_map do |entity|
-            if entity.is_a?(Lutaml::Uml::Association)
-              entity
-            elsif entity.is_a?(Lutaml::Uml::Class) && entity.associations
-              entity.associations
-            end
-          end.flatten
-        end
-
-        # Resolve a class or qualified name to a class object
-        #
-        # @param class_or_qname [Lutaml::Uml::Class, String] The class object
-        #   or qualified name string
-        # @return [Lutaml::Uml::Class, nil] The class object,
-        # or nil if not found
-        def resolve_class(class_or_qname)
-          if class_or_qname.is_a?(String)
-            indexes[:qualified_names][class_or_qname]
-          else
-            class_or_qname
-          end
-        end
-
-        # Check if an association matches the class name and direction
-        #
-        # @param assoc [Lutaml::Uml::Association] The association to check
-        # @param class_name [String] The class name to match
-        # @param direction [Symbol] The direction filter
-        # (:source, :target, :both)
-        # @return [Boolean] true if the association matches
-        def match_association?(assoc, class_name, direction) # rubocop:disable Metrics/MethodLength
-          case direction
-          when :source
-            # Class is the owner_end (source)
-            assoc.owner_end == class_name
-          when :target
-            # Class is the member_end (target)
-            assoc.member_end == class_name
-          when :both
-            # Class is either end
-            assoc.owner_end == class_name || assoc.member_end == class_name
-          else
-            false
-          end
-        end
-
-        # Check if an association is navigable
-        #
-        # An association is considered navigable if it has attribute names
-        # defined for navigation.
-        #
-        # @param assoc [Lutaml::Uml::Association] The association to check
-        # @return [Boolean] true if navigable
-        def navigable?(assoc)
-          # An association is navigable if it has member_end_attribute_name
-          # or owner_end_attribute_name defined
-          !assoc.member_end_attribute_name.nil? ||
-            !assoc.owner_end_attribute_name.nil?
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module Queries
-      # Base class for all query services.
-      #
-      # Provides common functionality for accessing the document and indexes
-      # that subclasses can use to implement specific query operations.
-      #
-      # @example Creating a custom query
-      #   class CustomQuery < BaseQuery
-      #     def find_something
-      #       indexes[:qualified_names]["ModelRoot::MyClass"]
-      #     end
-      #   end
-      #
-      #   query = CustomQuery.new(document, indexes)
-      #   result = query.find_something
-      class BaseQuery
-        # Create a new query instance
-        #
-        # @param document [Lutaml::Uml::Document] The UML document to query
-        # @param indexes [Hash] The indexes built by IndexBuilder
-        def initialize(document, indexes)
-          @document = document
-          @indexes = indexes
-        end
-
-        protected
-
-        attr_reader :document, :indexes
-
-        # Resolve all associations in the document
-        #
-        # @return [Array<Lutaml::Uml::Association>] Array of all associations
-        def find_class_by_id(class_id)
-          indexes[:qualified_names].find do |_qualified_name, entity|
-            entity.is_a?(Lutaml::Uml::Class) && entity.xmi_id == class_id
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module Queries
-      # Query service for class/classifier operations.
-      #
-      # Provides methods to find and query classes, data types, and enums
-      # using the qualified_names and stereotypes indexes.
-      #
-      # @example Finding a class by qualified name
-      #   query = ClassQuery.new(document, indexes)
-      #   klass = query.find_by_qname("ModelRoot::i-UR::urf::Building")
-      #
-      # @example Finding classes by stereotype
-      #   classes = query.find_by_stereotype("featureType")
-      #
-      # @example Getting classes in a package
-      #   classes = query.in_package("ModelRoot::i-UR::urf")
-      class ClassQuery < BaseQuery
-        # Find a class by its qualified name.
-        #
-        # @param qualified_name_string [String] The qualified name
-        #   (e.g., "ModelRoot::i-UR::urf::Building")
-        # @return [Lutaml::Uml::Class, Lutaml::Uml::DataType,
-        # Lutaml::Uml::Enum, nil]
-        #   The class object, or nil if not found
-        # @example
-        #   klass = query.find_by_qname("ModelRoot::i-UR::urf::Building")
-        def find_by_qname(qualified_name_string)
-          if qualified_name_string.nil? || qualified_name_string.empty?
-            return nil
-          end
-
-          indexes[:qualified_names][qualified_name_string]
-        end
-
-        # Find all classes with a specific stereotype.
-        #
-        # @param stereotype [String] The stereotype to search for
-        # @return [Array] Array of class objects with the stereotype
-        # @example
-        #   feature_types = query.find_by_stereotype("featureType")
-        #   # => [Class{name: "Building"}, Class{name: "Road"}, ...]
-        def find_by_stereotype(stereotype)
-          return [] if stereotype.nil? || stereotype.empty?
-
-          indexes[:stereotypes][stereotype] || []
-        end
-
-        # Get classes in a specific package.
-        #
-        # @param package_path_string [String] The package path
-        # @param recursive [Boolean] Whether to include classes from nested
-        #   packages (default: false)
-        # @return [Array] Array of class objects in the package
-        # @example Non-recursive query
-        #   classes = query.in_package(
-        #   "ModelRoot::i-UR::urf", recursive: false)
-        #   # Returns only classes directly in the urf package
-        #
-        # @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)
-          return [] if package_path_string.nil? || package_path_string.empty?
-
-          pkg_to_classes = indexes[:package_to_classes]
-          if pkg_to_classes
-            in_package_indexed(package_path_string, pkg_to_classes,
-                               recursive: recursive)
-          else
-            in_package_scan(package_path_string, recursive: recursive)
-          end
-        end
-
-        private
-
-        # O(1) indexed lookup for in_package
-        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|
-            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)
-          is_absolute = package_path.absolute?
-
-          indexes[:qualified_names].each_value.select do |klass|
-            scan_matches_package?(klass, package_path, is_absolute, recursive)
-          end
-        end
-
-        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
-  end
-end

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module Queries
-      # Query service for diagram operations.
-      #
-      # Provides methods to find and list diagrams from packages using the
-      # diagram_index which maps package IDs/paths to diagram collections.
-      #
-      # @example Finding diagrams in a package
-      #   query = DiagramQuery.new(document, indexes)
-      #   diagrams = query.in_package("ModelRoot::i-UR::urf")
-      #
-      # @example Finding a diagram by name
-      #   diagram = query.find_by_name("Class Diagram")
-      #
-      # @example Getting all diagrams
-      #   all_diagrams = query.all
-      class DiagramQuery < BaseQuery
-        # Get diagrams in a specific package.
-        #
-        # @param package_path_string [String] The package path
-        # @return [Array<Diagram>] Array of diagram objects in the package
-        # @example
-        #   diagrams = query.in_package("ModelRoot::i-UR::urf")
-        def in_package(package_path_string) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-          return [] if package_path_string.nil? || package_path_string.empty?
-
-          # Try to find diagrams by path
-          diagrams = indexes[:diagram_index][package_path_string]
-          return diagrams if diagrams
-
-          # Try to find the package and use its ID
-          package = indexes[:package_paths][package_path_string]
-          return [] unless package
-
-          package_id = package.is_a?(Lutaml::Uml::Package) ? package.xmi_id : nil
-          return [] unless package_id
-
-          indexes[:diagram_index][package_id] || []
-        end
-
-        # Find a diagram by its name.
-        #
-        #
-        # @param diagram_name [String] The diagram name to search for
-        # @return Diagram The diagram object, or nil if not found
-        # @example
-        #   diagram = query.find_by_name("Building Class Diagram")
-        def find_by_name(diagram_name)
-          indexes[:diagram_index].values.filter_map do |diagrams|
-            diagrams.select { |diagram| diagram.name == diagram_name }
-          end.flatten.first
-        end
-
-        # Find diagrams containing a specific package by its XMI ID.
-        #
-        # @param package_id [String] The XMI ID of the package
-        # @return [Array<Diagram>] Array of diagram objects
-        def find_by_package(package_id)
-          indexes[:diagram_index].values.filter_map do |diagrams|
-            diagrams.select { |diagram| diagram.package_id == package_id }
-          end.flatten
-        end
-
-        # Find diagrams containing a specific class by its XMI ID.
-        #
-        # @param class_xmi_id [String] The XMI ID of the class
-        # @return [Array<Diagram>] Array of diagram objects
-        def find_containing_class(class_xmi_id)
-          package = find_package_containing_class(class_xmi_id)
-          return [] unless package
-
-          find_by_package(package.xmi_id)
-        end
-
-        # Find the package containing a specific class by its XMI ID.
-        #
-        # @param class_xmi_id [String] The XMI ID of the class
-        # @return [Lutaml::Uml::Package, nil] The package object
-        def find_package_containing_class(class_xmi_id)
-          qualified_name, _klass = find_class_by_id(class_xmi_id)
-          return nil unless qualified_name
-
-          package_path = qualified_name.split("::")[0..-2].join("::")
-          indexes[:package_paths][package_path]
-        end
-
-        # Get all diagrams from all packages.
-        #
-        # @return [Array<Diagram>] Array of all diagram objects
-        # @example
-        #   all_diagrams = query.all
-        #   all_diagrams.each { |d| puts d.name }
-        def all
-          result = []
-
-          indexes[:diagram_index].each_value do |diagrams|
-            result.concat(diagrams)
-          end
-
-          result
-        end
-      end
-    end
-  end
-end