lutaml 0.10.4 → 0.10.6

data/lib/lutaml/uml_repository/index_builder.rb

@@ -2,6 +2,9 @@
 
 require_relative "../uml/package_path"
 require_relative "../uml/qualified_name"
+require_relative "index_builders/package_index"
+require_relative "index_builders/class_index"
+require_relative "index_builders/association_index"
 
 module Lutaml
   module UmlRepository
@@ -179,113 +182,6 @@ module Lutaml
         }.freeze
       end
 
-      # 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
-        @package_paths[ROOT_PACKAGE_NAME] = @document if @document
-
-        # Traverse all packages recursively
-        traverse_packages(@document.packages,
-                          parent_path: ROOT_PACKAGE_NAME) do |package, path|
-          @package_paths[path] = package
-          @package_to_path[package.xmi_id] = path if package.xmi_id
-        end
-      end
-
-      # 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 # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-        # Index top-level classes, data_types, and enums from document
-        if @document.classes
-          index_classifiers(@document.classes,
-                            ROOT_PACKAGE_NAME)
-        end
-        if @document.data_types
-          index_classifiers(@document.data_types,
-                            ROOT_PACKAGE_NAME)
-        end
-        index_classifiers(@document.enums, ROOT_PACKAGE_NAME) if @document.enums
-
-        # Traverse packages and index their classifiers
-        traverse_packages(@document.packages,
-                          parent_path: 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
-
-      def build_association_index # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        # Collect document-level associations (XMI format)
-        @document.associations&.each do |assoc|
-          next unless assoc.xmi_id
-
-          @associations[assoc.xmi_id] = assoc
-        end
-
-        # Collect class-level associations (QEA/EA format)
-        # Note: This requires qualified_names index to be built first
-        @qualified_names.each_value do |klass|
-          next unless klass.respond_to?(:associations) && klass.associations
-
-          klass.associations.each do |assoc|
-            next unless assoc.xmi_id
-
-            # Avoid duplicates - only add if not already present
-            @associations[assoc.xmi_id] ||= assoc
-          end
-        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 # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
-        # Process top-level classes
-        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
-
-        # Process classes in packages
-        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
-
-      # 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,
-                                  ROOT_PACKAGE_NAME)
-        end
-
-        # Process classes in packages
-        traverse_packages(@document.packages,
-                          parent_path: ROOT_PACKAGE_NAME) do |package, path|
-          process_generalizations(package.classes, path) if package.classes
-        end
-      end
-
       # Build the diagram index
       #
       # Creates a hash mapping package IDs/paths to arrays of Diagram objects:
@@ -303,170 +199,6 @@ module Lutaml
         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
-
-      # 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) # rubocop:disable Metrics/MethodLength
-        return unless classifiers
-
-        classifiers.each do |classifier|
-          next unless classifier.name
-
-          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] ||= []
-          @simple_name_to_qnames[classifier.name] << qualified_name
-          (@package_to_classes[package_path] ||= []) << classifier
-        end
-      end
-
-      # Index classifiers by their stereotypes
-      #
-      # @param classifiers [Array] Array of classifier objects
-      def index_by_stereotype(classifiers) # rubocop:disable Metrics/CyclomaticComplexity
-        return unless classifiers
-
-        classifiers.each do |classifier|
-          next unless classifier.stereotype && !classifier.stereotype.empty?
-
-          # Handle both String and Array stereotypes
-          stereotypes = Array(classifier.stereotype)
-          stereotypes.each do |stereotype|
-            @stereotypes[stereotype] ||= []
-            @stereotypes[stereotype] << classifier
-          end
-        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) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        return unless classes
-
-        classes.each do |klass|
-          next unless klass.name
-
-          child_qname = "#{package_path}::#{klass.name}"
-
-          # Handle generalization attribute
-          if klass.generalization
-            parent_name = extract_parent_name(klass.generalization)
-            if parent_name
-              parent_qname = resolve_qualified_name(parent_name, package_path)
-              if parent_qname && child_qname != parent_qname
-                @inheritance_graph[parent_qname] ||= []
-                @inheritance_graph[parent_qname] << child_qname
-              end
-            end
-          end
-
-          # Handle inheritance associations
-          next unless klass.associations
-
-          klass.associations.each do |assoc|
-            next unless assoc.respond_to?(:member_end_type)
-            next unless assoc.member_end_type == "inheritance"
-
-            parent_name = assoc.member_end
-            next unless parent_name
-
-            parent_name = parent_name.name if parent_name.respond_to?(:name)
-            next unless parent_name.is_a?(String) && !parent_name.empty?
-
-            parent_qname = resolve_qualified_name(parent_name, package_path)
-            next unless parent_qname
-            next if child_qname == parent_qname
-
-            @inheritance_graph[parent_qname] ||= []
-            @inheritance_graph[parent_qname] << child_qname
-          end
-        end
-      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) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-        return nil unless generalization
-
-        # Check for general attribute (could be a string or object)
-        if generalization.respond_to?(:general)
-          parent = generalization.general
-          return parent.name if parent.respond_to?(:name)
-          return parent.to_s if parent
-        end
-
-        # Check for name attribute directly
-        if generalization.respond_to?(:name) && generalization.name
-          return generalization.name
-        end
-
-        nil
-      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 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
-
       private
 
       # Convert a hash with default proc to a plain hash (Marshal-safe)

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    class IndexBuilder
+      def build_association_index # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        # Collect document-level associations (XMI format)
+        @document.associations&.each do |assoc|
+          next unless assoc.xmi_id
+
+          @associations[assoc.xmi_id] = assoc
+        end
+
+        # Collect class-level associations (QEA/EA format)
+        # Note: This requires qualified_names index to be built first
+        @qualified_names.each_value do |klass|
+          next unless klass.respond_to?(:associations) && klass.associations
+
+          klass.associations.each do |assoc|
+            next unless assoc.xmi_id
+
+            # Avoid duplicates - only add if not already present
+            @associations[assoc.xmi_id] ||= assoc
+          end
+        end
+      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,
+                                  ROOT_PACKAGE_NAME)
+        end
+
+        # Process classes in packages
+        traverse_packages(@document.packages,
+                          parent_path: 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) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        return unless classes
+
+        classes.each do |klass|
+          next unless klass.name
+
+          child_qname = "#{package_path}::#{klass.name}"
+
+          # Handle generalization attribute
+          if klass.generalization
+            parent_name = extract_parent_name(klass.generalization)
+            if parent_name
+              parent_qname = resolve_qualified_name(parent_name, package_path)
+              if parent_qname && child_qname != parent_qname
+                @inheritance_graph[parent_qname] ||= []
+                @inheritance_graph[parent_qname] << child_qname
+              end
+            end
+          end
+
+          # Handle inheritance associations
+          next unless klass.associations
+
+          klass.associations.each do |assoc|
+            next unless assoc.respond_to?(:member_end_type)
+            next unless assoc.member_end_type == "inheritance"
+
+            parent_name = assoc.member_end
+            next unless parent_name
+
+            parent_name = parent_name.name if parent_name.respond_to?(:name)
+            next unless parent_name.is_a?(String) && !parent_name.empty?
+
+            parent_qname = resolve_qualified_name(parent_name, package_path)
+            next unless parent_qname
+            next if child_qname == parent_qname
+
+            @inheritance_graph[parent_qname] ||= []
+            @inheritance_graph[parent_qname] << child_qname
+          end
+        end
+      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) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        return nil unless generalization
+
+        # Check for general attribute (could be a string or object)
+        if generalization.respond_to?(:general)
+          parent = generalization.general
+          return parent.name if parent.respond_to?(:name)
+          return parent.to_s if parent
+        end
+
+        # Check for name attribute directly
+        if generalization.respond_to?(:name) && generalization.name
+          return generalization.name
+        end
+
+        nil
+      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 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

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    class IndexBuilder
+      # 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 # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+        # Index top-level classes, data_types, and enums from document
+        if @document.classes
+          index_classifiers(@document.classes,
+                            ROOT_PACKAGE_NAME)
+        end
+        if @document.data_types
+          index_classifiers(@document.data_types,
+                            ROOT_PACKAGE_NAME)
+        end
+        index_classifiers(@document.enums, ROOT_PACKAGE_NAME) if @document.enums
+
+        # Traverse packages and index their classifiers
+        traverse_packages(@document.packages,
+                          parent_path: 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 # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        # Process top-level classes
+        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
+
+        # Process classes in packages
+        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) # rubocop:disable Metrics/MethodLength
+        return unless classifiers
+
+        classifiers.each do |classifier|
+          next unless classifier.name
+
+          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] ||= []
+          @simple_name_to_qnames[classifier.name] << qualified_name
+          (@package_to_classes[package_path] ||= []) << classifier
+        end
+      end
+
+      # Index classifiers by their stereotypes
+      #
+      # @param classifiers [Array] Array of classifier objects
+      def index_by_stereotype(classifiers) # rubocop:disable Metrics/CyclomaticComplexity
+        return unless classifiers
+
+        classifiers.each do |classifier|
+          next unless classifier.stereotype && !classifier.stereotype.empty?
+
+          # Handle both String and Array stereotypes
+          stereotypes = Array(classifier.stereotype)
+          stereotypes.each do |stereotype|
+            @stereotypes[stereotype] ||= []
+            @stereotypes[stereotype] << classifier
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    class IndexBuilder
+      # 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
+        @package_paths[ROOT_PACKAGE_NAME] = @document if @document
+
+        # Traverse all packages recursively
+        traverse_packages(@document.packages,
+                          parent_path: 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

data/lib/lutaml/uml_repository/package_exporter.rb

@@ -53,8 +53,8 @@ module Lutaml
       # @param options [Hash] Export options
       # @option options [PackageMetadata, Hash] :metadata Package metadata
       #   (can be PackageMetadata object or Hash)
-      # @option options [Symbol] :serialization_format (:marshal) Format for
-      #   Document serialization (:marshal or :yaml)
+      # @option options [Symbol] :serialization_format (:yaml) Format for
+      #   Document serialization (:yaml)
       # @option options [Boolean] :include_xmi (false) Include source XMI
       #   in package
       # @option options [Integer] :compression_level (6) ZIP compression level
@@ -106,7 +106,7 @@ module Lutaml
       # @return [Hash] Default options
       def default_options
         {
-          serialization_format: :marshal,
+          serialization_format: :yaml,
           include_xmi: false,
           compression_level: 6,
           name: "UML Model",
@@ -154,10 +154,9 @@ module Lutaml
       # @raise [ArgumentError] If options are invalid
       def validate_options!
         format = @options[:serialization_format]
-        unless %i[marshal yaml].include?(format)
+        unless format == :yaml
           raise ArgumentError,
-                "Invalid serialization format: #{format}. " \
-                "Must be :marshal or :yaml"
+                "Invalid serialization format: #{format}. Must be :yaml"
         end
       end
 
@@ -191,18 +190,9 @@ module Lutaml
       #
       # @param zip [Zip::File] The ZIP archive
       # @return [void]
-      def write_document(zip) # rubocop:disable Metrics/MethodLength
-        format = @options[:serialization_format]
-
-        case format
-        when :yaml
-          zip.get_output_stream("repository.yaml") do |io|
-            io.write(@repository.document.to_yaml)
-          end
-        when :marshal
-          zip.get_output_stream("repository.marshal") do |io|
-            io.write(Marshal.dump(@repository.document))
-          end
+      def write_document(zip)
+        zip.get_output_stream("repository.yaml") do |io|
+          io.write(@repository.document.to_yaml)
         end
       end
 
@@ -211,8 +201,8 @@ module Lutaml
       # @param zip [Zip::File] The ZIP archive
       # @return [void]
       def write_indexes(zip)
-        zip.get_output_stream("indexes/all.marshal") do |io|
-          io.write(Marshal.dump(@repository.indexes))
+        zip.get_output_stream("indexes/all.yaml") do |io|
+          io.write(YAML.dump(@repository.indexes))
         end
       end