lutaml 0.9.43 → 0.10.0

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "element_presenter"
+require_relative "presenter_factory"
+
+module Lutaml
+  module UmlRepository
+    module Presenters
+      # Presenter for UML Package elements.
+      #
+      # Formats package information for different output types:
+      # text, table rows, and structured data.
+      class PackagePresenter < ElementPresenter
+        # Generate detailed text view.
+        #
+        # @return [String] Multi-line formatted text
+        def to_text # rubocop:disable Metrics/AbcSize
+          lines = []
+          lines << "Package: #{element.name}"
+          lines << ("=" * 50)
+          lines << ""
+          lines << "Name:        #{element.name}"
+          if element.respond_to?(:xmi_id)
+            lines << "XMI ID:      #{element.xmi_id}"
+          end
+          lines.join("\n")
+        end
+
+        # Generate structured hash.
+        #
+        # @return [Hash] Structured representation
+        def to_hash
+          data = {
+            type: "Package",
+            name: element.name,
+          }
+
+          data[:xmi_id] = element.xmi_id if element.respond_to?(:xmi_id)
+
+          data
+        end
+      end
+
+      # Register with factory
+      PresenterFactory.register(Lutaml::Uml::Package, PackagePresenter)
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "element_presenter"
+
+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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "base_query"
+require_relative "inheritance_query"
+
+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.respond_to?(:associations) && klass.associations
+            results.concat(klass.associations)
+          end
+
+          # Get associations from document level unless owned_only
+          if !owned_only &&
+              document.respond_to?(:associations) && 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

@@ -0,0 +1,45 @@
+# 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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "base_query"
+require_relative "../../uml/qualified_name"
+require_relative "../../uml/package_path"
+
+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) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return [] if package_path_string.nil? || package_path_string.empty?
+
+          package_path = Lutaml::Uml::PackagePath.new(package_path_string)
+          results = []
+
+          # Check if the path is absolute (starts with ModelRoot)
+          is_absolute = package_path.absolute?
+
+          indexes[:qualified_names].each do |qname_string, klass| # rubocop:disable Metrics/BlockLength
+            qname = Lutaml::Uml::QualifiedName.new(qname_string)
+
+            matched = if is_absolute
+                        # Absolute path - exact match
+                        if recursive
+                          qname.package_path.starts_with?(package_path)
+                        else
+                          qname.package_path == package_path
+                        end
+                      else
+                        # Relative path - match if the class's package path ends with
+                        # the given path
+                        class_pkg_segs = qname.package_path.segments
+                        search_segs = package_path.segments
+
+                        if recursive
+                          # For recursive, check if any suffix of the class path
+                          # starts with search_segs
+                          (0..(class_pkg_segs.size - search_segs.size))
+                            .any? do |i|
+                            class_pkg_segs[i, search_segs.size] == search_segs
+                          end
+                        else
+                          # For non-recursive, check if class path ends with
+                          # search_segs
+                          class_pkg_segs.size >= search_segs.size &&
+                            class_pkg_segs[-search_segs.size..] == search_segs
+                        end
+                      end
+
+            results << klass if matched
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "base_query"
+require_relative "../../uml/package_path"
+
+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.respond_to?(:xmi_id) ? 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