lutaml 0.10.19 → 0.11.2

data/lib/lutaml/uml_repository/index_builder.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    # IndexBuilder builds fast lookup indexes from a Lutaml::Uml::Document
-    #
-    # This class creates immutable hash indexes that enable O(1) lookups for:
-    # - Package paths (e.g., "ModelRoot::i-UR::urf")
-    # - Qualified names (e.g., "ModelRoot::i-UR::urf::Building")
-    # - Stereotypes (e.g., "featureType" => [Class, Class, ...])
-    # - Inheritance graph (parent_qname => [child_qname, ...])
-    # - Diagram index (package_id => [Diagram, ...])
-    # - Package to path mapping (package_id => path)
-    # - Class to qualified name mapping (class_id => qualified_name)
-    # - Classes (class_id => Class)
-    # - Associations (association_id => Association)
-    #
-    # All indexes are frozen to ensure immutability.
-    #
-    # @example Building all indexes from a document
-    #   indexes = IndexBuilder.build_all(document)
-    #   package = indexes[:package_paths]["ModelRoot::i-UR"]
-    #   klass = indexes[:qualified_names]["ModelRoot::i-UR::Building"]
-    class IndexBuilder
-      include IndexBuilders::PackageIndex
-      include IndexBuilders::ClassIndex
-      include IndexBuilders::AssociationIndex
-
-      ROOT_PACKAGE_NAME = "ModelRoot"
-
-      # Build all indexes from a UML document
-      #
-      # @param document [Lutaml::Uml::Document] The UML document to index
-      # @return [Hash] A frozen hash containing all indexes with keys:
-      #   - :package_paths - Maps package paths to Package objects
-      #   - :qualified_names - Maps qualified names to
-      #     Class/DataType/Enum objects
-      #   - :stereotypes - Groups classes by stereotype
-      #   - :inheritance_graph - Maps parent qualified names to child
-      #     qualified names
-      #   - :diagram_index - Maps package IDs/paths to Diagram objects
-      #   - :package_to_path - Maps package XMI IDs to paths
-      #   - :class_to_qname - Maps class XMI IDs to qualified names
-      #   - :classes - Maps class XMI IDs to Class objects
-      #   - :associations - Maps association XMI IDs to Association objects
-      def self.build_all(document)
-        new(document).build_all
-      end
-
-      # Build package paths index
-      #
-      # @param document [Lutaml::Uml::Document] The UML document
-      # @return [Hash] Frozen hash mapping package paths to Package objects
-      def self.build_package_paths(document)
-        builder = new(document)
-        builder.build_package_path_index
-        builder.package_paths.freeze
-      end
-
-      def self.build_package_to_path(document)
-        builder = new(document)
-        builder.build_package_path_index
-        builder.package_to_path.freeze
-      end
-
-      # Build qualified names index
-      #
-      # @param document [Lutaml::Uml::Document] The UML document
-      # @return [Hash] Frozen hash mapping qualified names to Class objects
-      def self.build_qualified_names(document)
-        builder = new(document)
-        builder.build_qualified_name_index
-        builder.qualified_names.freeze
-      end
-
-      def self.build_class_to_qname(document)
-        builder = new(document)
-        builder.build_qualified_name_index
-        builder.class_to_qname.freeze
-      end
-
-      def self.build_classes(document)
-        builder = new(document)
-        builder.build_qualified_name_index
-        builder.classes.freeze
-      end
-
-      def self.build_associations(document)
-        builder = new(document)
-        # build_association_index needs @qualified_names to collect
-        # class-level associations
-        builder.build_qualified_name_index
-        builder.build_association_index
-        builder.associations.freeze
-      end
-
-      # Build stereotypes index
-      #
-      # @param document [Lutaml::Uml::Document] The UML document
-      # @return [Hash] Frozen hash grouping classes by stereotype
-      def self.build_stereotypes(document)
-        builder = new(document)
-        builder.build_stereotype_index
-        builder.stereotypes.freeze
-      end
-
-      # Build inheritance graph index
-      #
-      # @param document [Lutaml::Uml::Document] The UML document
-      # @param indexes [Hash, nil] Existing indexes (requires :qualified_names)
-      # @return [Hash] Frozen hash mapping parent qnames to child qnames
-      def self.build_inheritance_graph(document, indexes)
-        builder = new(document)
-        if indexes && indexes[:qualified_names]
-          builder.qualified_names = indexes[:qualified_names]
-        else
-          builder.build_qualified_name_index
-        end
-        builder.build_inheritance_graph_index
-        builder.inheritance_graph.freeze
-      end
-
-      # Build diagram index
-      #
-      # @param document [Lutaml::Uml::Document] The UML document
-      # @param indexes [Hash, nil] Existing indexes (requires :package_paths)
-      # @return [Hash] Frozen hash mapping package IDs to Diagram objects
-      def self.build_diagram_index(document, indexes)
-        builder = new(document)
-        if indexes && indexes[:package_paths]
-          builder.package_paths = indexes[:package_paths]
-        else
-          builder.build_package_path_index
-        end
-        builder.build_diagram_index
-        builder.diagram_index.freeze
-      end
-
-      def initialize(document)
-        @document = document
-        @package_paths = {}
-        @qualified_names = {}
-        @stereotypes = {}
-        @inheritance_graph = {}
-        @diagram_index = {}
-        @package_to_path = {}
-        @class_to_qname = {}
-        @classes = {}
-        @associations = {}
-        @simple_name_to_qnames = {}
-        @package_to_classes = {}
-      end
-
-      attr_accessor :package_paths, :qualified_names
-      attr_reader :package_to_path, :class_to_qname, :classes, :associations,
-                  :stereotypes, :inheritance_graph, :diagram_index
-
-      # Build all indexes and return them as a frozen hash
-      #
-      # @return [Hash] Frozen hash containing all indexes
-      def build_all # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        build_package_path_index
-        build_qualified_name_index
-        build_stereotype_index
-        build_inheritance_graph_index
-        build_diagram_index
-        build_association_index
-
-        {
-          package_paths: @package_paths.freeze,
-          qualified_names: @qualified_names.freeze,
-          stereotypes: @stereotypes.freeze,
-          inheritance_graph: @inheritance_graph.freeze,
-          diagram_index: @diagram_index.freeze,
-          package_to_path: @package_to_path.freeze,
-          class_to_qname: @class_to_qname.freeze,
-          classes: @classes.freeze,
-          associations: @associations.freeze,
-          package_to_classes: plain_hash(@package_to_classes).freeze,
-        }.freeze
-      end
-
-      # Build the diagram index
-      #
-      # Creates a hash mapping package IDs/paths to arrays of Diagram objects:
-      #   "package_id" => [Diagram{}, Diagram{}]
-      # @api public
-      def build_diagram_index
-        # Traverse packages and collect diagrams
-        traverse_packages(@document.packages) do |package, path|
-          next unless package.diagrams && !package.diagrams.empty?
-
-          # Index by package ID if available, otherwise by path
-          key = package.xmi_id || path
-          @diagram_index[key] ||= []
-          @diagram_index[key].concat(package.diagrams)
-        end
-      end
-
-      private
-
-      # Convert a hash with default proc to a plain hash (Marshal-safe)
-      # @param hash [Hash] Hash possibly with default proc
-      # @return [Hash] Plain hash without default proc
-      def plain_hash(hash_with_default)
-        hash_with_default.each_with_object({}) { |(k, v), h| h[k] = v }
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/index_builders/association_index.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module IndexBuilders
-      module AssociationIndex
-        def build_association_index
-          index_document_associations
-          index_class_level_associations
-        end
-
-        def index_document_associations
-          @document.associations&.each do |assoc|
-            next unless assoc.xmi_id
-
-            @associations[assoc.xmi_id] = assoc
-          end
-        end
-
-        def index_class_level_associations
-          @qualified_names.each_value do |klass|
-            next unless klassifiable?(klass) && klass.associations
-
-            klass.associations.each do |assoc|
-              next unless assoc.xmi_id
-
-              @associations[assoc.xmi_id] ||= assoc
-            end
-          end
-        end
-
-        def klassifiable?(klass)
-          klass.is_a?(Lutaml::Uml::Class) || klass.is_a?(Lutaml::Uml::DataType)
-        end
-
-        # Build the inheritance graph index
-        #
-        # Creates a hash mapping parent qualified names to arrays of
-        # child qualified names:
-        #   "ModelRoot::Parent" => ["ModelRoot::Child1", "ModelRoot::Child2"]
-        # @api public
-        def build_inheritance_graph_index
-          # Process top-level classes
-          if @document.classes
-            process_generalizations(@document.classes,
-                                    IndexBuilder::ROOT_PACKAGE_NAME)
-          end
-
-          # Process classes in packages
-          traverse_packages(@document.packages,
-                            parent_path: IndexBuilder::ROOT_PACKAGE_NAME) do |package, path|
-            process_generalizations(package.classes, path) if package.classes
-          end
-        end
-
-        # Process generalization relationships to build inheritance graph
-        #
-        # @param classes [Array<Lutaml::Uml::Class>] Classes to process
-        # @param package_path [String] Package path for these classes
-        def process_generalizations(classes, package_path)
-          return unless classes
-
-          classes.each do |klass|
-            next unless klass.name
-
-            child_qname = "#{package_path}::#{klass.name}"
-            index_generalization_edge(child_qname, klass, package_path)
-            index_inheritance_assoc_edges(child_qname, klass, package_path)
-          end
-        end
-
-        def index_generalization_edge(child_qname, klass, package_path)
-          return unless klass.generalization
-
-          parent_name = extract_parent_name(klass.generalization)
-          return unless parent_name
-
-          parent_qname = resolve_qualified_name(parent_name, package_path)
-          return unless parent_qname && child_qname != parent_qname
-
-          (@inheritance_graph[parent_qname] ||= []) << child_qname
-        end
-
-        def index_inheritance_assoc_edges(child_qname, klass, package_path)
-          return unless klass.associations
-
-          klass.associations
-            .select { |assoc| assoc.member_end_type == "inheritance" }
-            .each do |assoc|
-            index_inheritance_edge(child_qname, assoc,
-                                   package_path)
-          end
-        end
-
-        def index_inheritance_edge(child_qname, assoc, package_path)
-          parent_name = resolve_parent_name_from_assoc(assoc)
-          return unless parent_name
-
-          parent_qname = resolve_qualified_name(parent_name, package_path)
-          return unless parent_qname && child_qname != parent_qname
-
-          (@inheritance_graph[parent_qname] ||= []) << child_qname
-        end
-
-        def resolve_parent_name_from_assoc(assoc)
-          parent_name = assoc.member_end
-          return nil unless parent_name
-
-          parent_name = parent_name.name if parent_name.is_a?(Lutaml::Uml::Generalization)
-          parent_name.is_a?(String) && !parent_name.empty? ? parent_name : nil
-        end
-
-        # Extract parent name from generalization object
-        #
-        # @param generalization [Lutaml::Uml::Generalization]
-        # Generalization object
-        # @return [String, nil] Parent class name
-        def extract_parent_name(generalization)
-          return nil unless generalization
-
-          name_from_general(generalization) || generalization.name
-        end
-
-        # Resolve a class name to its qualified name
-        #
-        # This is a simplified resolution that checks:
-        # 1. Same package
-        # 2. Already qualified name in index
-        #
-        # @param name [String] Class name to resolve
-        # @param current_package_path [String] Current package context
-        # @return [String, nil] Resolved qualified name
-        def name_from_general(generalization)
-          parent = generalization.general
-          return nil unless parent
-
-          parent.is_a?(String) ? parent : parent.name
-        end
-
-        def resolve_qualified_name(name, current_package_path)
-          # If name contains "::", it might already be qualified
-          return name if @qualified_names.key?(name)
-
-          # Try in current package
-          local_qname = "#{current_package_path}::#{name}"
-          return local_qname if @qualified_names.key?(local_qname)
-
-          # O(1) lookup using reverse index instead of O(n) scan
-          candidates = @simple_name_to_qnames[name]
-          candidates&.first
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/index_builders/class_index.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module IndexBuilders
-      module ClassIndex
-        # Build the qualified name index
-        #
-        # Creates a hash mapping qualified names to Class/DataType/Enum objects:
-        #   "ModelRoot::i-UR::urf::Building" => Class{}
-        # @api public
-        def build_qualified_name_index
-          index_document_classifiers
-          index_package_classifiers
-        end
-
-        def index_document_classifiers
-          if @document.classes
-            index_classifiers(@document.classes,
-                              IndexBuilder::ROOT_PACKAGE_NAME)
-          end
-          if @document.data_types
-            index_classifiers(@document.data_types,
-                              IndexBuilder::ROOT_PACKAGE_NAME)
-          end
-          if @document.enums
-            index_classifiers(@document.enums,
-                              IndexBuilder::ROOT_PACKAGE_NAME)
-          end
-        end
-
-        def index_package_classifiers
-          traverse_packages(@document.packages,
-                            parent_path: IndexBuilder::ROOT_PACKAGE_NAME) do |package, path|
-            index_classifiers(package.classes, path) if package.classes
-            index_classifiers(package.data_types, path) if package.data_types
-            index_classifiers(package.enums, path) if package.enums
-          end
-        end
-
-        # Build the stereotype index
-        #
-        # Creates a hash grouping classes by their stereotype:
-        #   "featureType" => [Class{}, Class{}],
-        #   "dataType" => [Class{}]
-        # @api public
-        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
-
-        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
-            index_by_stereotype(package.enums) if package.enums
-          end
-        end
-
-        # Index classifiers (classes, data types, enums) by their qualified names
-        #
-        # @param classifiers [Array] Array of classifier objects
-        # @param package_path [String] Package path for these classifiers
-        def index_classifiers(classifiers, package_path)
-          return unless classifiers
-
-          classifiers.each do |classifier|
-            next unless classifier.name
-
-            index_classifier(classifier, package_path)
-          end
-        end
-
-        def index_classifier(classifier, package_path)
-          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] ||= []) << 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)
-          return unless classifiers
-
-          classifiers.each do |classifier|
-            next unless has_stereotype?(classifier)
-
-            Array(classifier.stereotype).each do |stereotype|
-              (@stereotypes[stereotype] ||= []) << classifier
-            end
-          end
-        end
-
-        def has_stereotype?(classifier)
-          classifier.stereotype && !classifier.stereotype.empty?
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/index_builders/package_index.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module IndexBuilders
-      module PackageIndex
-        # Build the package path index
-        #
-        # Creates a hash mapping package paths to Package objects:
-        #   "ModelRoot" => Package{},
-        #   "ModelRoot::i-UR" => Package{},
-        #   "ModelRoot::i-UR::urf" => Package{}
-        # @api public
-        def build_package_path_index
-          # Add root package if it exists
-          if @document
-            @package_paths[IndexBuilder::ROOT_PACKAGE_NAME] =
-              @document
-          end
-
-          # Traverse all packages recursively
-          traverse_packages(@document.packages,
-                            parent_path: IndexBuilder::ROOT_PACKAGE_NAME) do |package, path|
-            @package_paths[path] = package
-            @package_to_path[package.xmi_id] = path if package.xmi_id
-          end
-        end
-
-        # Traverse packages recursively, yielding each package with its path
-        #
-        # @param packages [Array<Lutaml::Uml::Package>] Packages to traverse
-        # @param parent_path [String, nil] Parent package path
-        # @yield [package, path] Yields each package with its full path
-        def traverse_packages(packages, parent_path: nil, &block)
-          return unless packages
-
-          packages.each do |package|
-            path = build_package_path(package.name, parent_path)
-            yield package, path if block
-
-            # Recursively traverse nested packages
-            if package.packages
-              traverse_packages(package.packages, parent_path: path,
-                                &block)
-            end
-          end
-        end
-
-        # Build a package path from a package name and parent path
-        #
-        # @param name [String] Package name
-        # @param parent_path [String, nil] Parent package path
-        # @return [String] Full package path
-        def build_package_path(name, parent_path)
-          return name unless parent_path
-
-          "#{parent_path}::#{name}"
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/index_builders.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module IndexBuilders
-      autoload :PackageIndex,
-               "lutaml/uml_repository/index_builders/package_index"
-      autoload :ClassIndex, "lutaml/uml_repository/index_builders/class_index"
-      autoload :AssociationIndex,
-               "lutaml/uml_repository/index_builders/association_index"
-    end
-  end
-end