lutaml 0.10.2 → 0.10.4

data/lib/lutaml/qea/factory/class_transformer.rb

@@ -108,15 +108,9 @@ module Lutaml
         def load_attributes(object_id)
           return [] if object_id.nil?
 
-          # Query t_attribute table
-          query = "SELECT * FROM t_attribute WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
+          ea_attributes = database.attributes_for_object(object_id)
+            .sort_by { |a| a.pos || 0 }
 
-          ea_attributes = rows.map do |row|
-            Models::EaAttribute.from_db_row(row)
-          end
-
-          # Transform to UML attributes
           attribute_transformer = AttributeTransformer.new(database)
           attribute_transformer.transform_collection(ea_attributes)
         end
@@ -127,15 +121,9 @@ module Lutaml
         def load_operations(object_id)
           return [] if object_id.nil?
 
-          # Query t_operation table
-          query = "SELECT * FROM t_operation WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
-
-          ea_operations = rows.map do |row|
-            Models::EaOperation.from_db_row(row)
-          end
+          ea_operations = database.operations_for_object(object_id)
+            .sort_by { |op| op.pos || 0 }
 
-          # Transform to UML operations
           operation_transformer = OperationTransformer.new(database)
           operation_transformer.transform_collection(ea_operations)
         end
@@ -245,24 +233,21 @@ module Lutaml
           return nil unless current_obj
 
           # 2. Find generalization connector where this class is the subtype
-          query = "SELECT * FROM t_connector WHERE Start_Object_ID = ? " \
-                  "AND Connector_Type = 'Generalization' LIMIT 1"
-          rows = database.connection.execute(query, object_id)
+          ea_connector = database.connectors_for_object(object_id)
+            .find { |c| c.generalization? && c.start_object_id == object_id }
 
           # 3. Create generalization object for current class
           # Even if no parent exists, we need a Generalization
           # representing this class
-          if rows.empty?
+          gen_transformer = GeneralizationTransformer.new(database)
+          generalization = if ea_connector.nil?
             # No parent - create terminal generalization
-            gen_transformer = GeneralizationTransformer.new(database)
-            generalization = gen_transformer.transform(nil, current_obj)
+            gen_transformer.transform(nil, current_obj)
           else
             # Has parent - create generalization with parent connector
-            ea_connector = Models::EaConnector.from_db_row(rows.first)
-            gen_transformer = GeneralizationTransformer.new(database)
-            generalization = gen_transformer
+            gen_transformer
               .transform(ea_connector, current_obj)
-          end
+                           end
           return nil unless generalization
 
           # 4. Load CURRENT object attributes and convert to GeneralAttribute
@@ -452,19 +437,13 @@ module Lutaml
         def load_association_generalizations(object_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
           return [] if object_id.nil?
 
-          # Query for ALL generalization connectors for this class
-          query = "SELECT ea_guid, End_Object_ID FROM t_connector " \
-                  "WHERE Start_Object_ID = ? " \
-                  "AND Connector_Type = 'Generalization'"
-          rows = database.connection.execute(query, object_id)
+          # Find ALL generalization connectors for this class
+          gen_connectors = database.connectors_for_object(object_id)
+            .select { |c| c.generalization? && c.start_object_id == object_id }
 
-          rows.filter_map do |row|
-            guid = row.is_a?(Hash) ? (row["ea_guid"] || row[:ea_guid]) : row[0]
-            parent_object_id = if row.is_a?(Hash)
-                                 row["End_Object_ID"] || row[:End_Object_ID]
-                               else
-                                 row[1]
-                               end
+          gen_connectors.filter_map do |ea_connector|
+            guid = ea_connector.ea_guid
+            parent_object_id = ea_connector.end_object_id
 
             # Find parent object to get its GUID
             parent_obj = find_object_by_id(parent_object_id)
@@ -493,16 +472,11 @@ module Lutaml
           normalized_owner_xmi_id = normalize_guid_to_xmi_format(object_guid,
                                                                  "EAID")
 
-          # Find all association-type connectors where this class participates
-          query = "SELECT * FROM t_connector " \
-                  "WHERE (Start_Object_ID = ? OR End_Object_ID = ?) " \
-                  "AND Connector_Type IN " \
-                  "('Association', 'Aggregation', 'Composition')"
-          rows = database.connection.execute(query, [object_id, object_id])
-
-          rows.each do |row| # rubocop:disable Metrics/BlockLength
-            ea_connector = Models::EaConnector.from_db_row(row)
+          assoc_types = ["Association", "Aggregation", "Composition"].freeze
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| assoc_types.include?(c.connector_type) }
 
+          assoc_connectors.each do |ea_connector| # rubocop:disable Metrics/BlockLength
             # Determine which end this class is on
             is_start = ea_connector.start_object_id == object_id
 
@@ -600,19 +574,13 @@ module Lutaml
 
           attributes = []
 
-          # Find all association-type connectors
-          # (Association, Aggregation, Composition)
-          query = "SELECT * FROM t_connector " \
-                  "WHERE (Start_Object_ID = ? OR End_Object_ID = ?) " \
-                  "AND Connector_Type IN " \
-                  "('Association', 'Aggregation', 'Composition')"
-          rows = database.connection.execute(query, [object_id, object_id])
+          assoc_types = ["Association", "Aggregation", "Composition"].freeze
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| assoc_types.include?(c.connector_type) }
           obj = find_object_by_id(object_id)
           obj_pkg_name = find_package_name(obj&.package_id)
 
-          rows.each do |row| # rubocop:disable Metrics/BlockLength
-            ea_connector = Models::EaConnector.from_db_row(row)
-
+          assoc_connectors.each do |ea_connector| # rubocop:disable Metrics/BlockLength
             # Check if this object is the source (owner) or target (member)
             if ea_connector.start_object_id == object_id
               # This class is the source - check for dest role
@@ -711,11 +679,7 @@ module Lutaml
         def find_package_name(package_id)
           return nil if package_id.nil?
 
-          query = "SELECT NAME FROM t_package WHERE Package_ID = ?"
-          rows = database.connection.execute(query, [package_id])
-          return nil if rows.empty?
-
-          rows.first["Name"]
+          database.find_package(package_id)&.name
         end
       end
     end

data/lib/lutaml/qea/factory/data_type_transformer.rb

@@ -64,12 +64,8 @@ module Lutaml
         def load_attributes(object_id)
           return [] if object_id.nil?
 
-          query = "SELECT * FROM t_attribute WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
-
-          ea_attributes = rows.map do |row|
-            Models::EaAttribute.from_db_row(row)
-          end
+          ea_attributes = database.attributes_for_object(object_id)
+            .sort_by { |a| a.pos || 0 }
 
           attribute_transformer = AttributeTransformer.new(database)
           attribute_transformer.transform_collection(ea_attributes)
@@ -81,12 +77,8 @@ module Lutaml
         def load_operations(object_id)
           return [] if object_id.nil?
 
-          query = "SELECT * FROM t_operation WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
-
-          ea_operations = rows.map do |row|
-            Models::EaOperation.from_db_row(row)
-          end
+          ea_operations = database.operations_for_object(object_id)
+            .sort_by { |op| op.pos || 0 }
 
           operation_transformer = OperationTransformer.new(database)
           operation_transformer.transform_collection(ea_operations)
@@ -129,19 +121,13 @@ module Lutaml
         def load_associations(object_id, object_guid) # rubocop:disable Metrics/MethodLength
           return [] if object_id.nil?
 
-          query = <<-SQL
-            SELECT * FROM t_connector
-            WHERE Connector_Type = 'Association'
-            AND (Start_Object_ID = ? OR End_Object_ID = ?)
-          SQL
-
-          rows = database.connection.execute(query, [object_id, object_id])
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| c.connector_type == "Association" }
 
           assoc_transformer = AssociationTransformer.new(database)
           normalized_xmi_id = normalize_guid_to_xmi_format(object_guid, "EAID")
 
-          rows.filter_map do |row|
-            ea_connector = Models::EaConnector.from_db_row(row)
+          assoc_connectors.filter_map do |ea_connector|
             assoc = assoc_transformer.transform(ea_connector)
 
             next unless assoc && assoc.owner_end_xmi_id == normalized_xmi_id

data/lib/lutaml/qea/factory/diagram_transformer.rb

@@ -72,11 +72,7 @@ module Lutaml
         def find_package(package_id)
           return nil if package_id.nil?
 
-          query = "SELECT * FROM t_package WHERE Package_ID = ?"
-          rows = database.connection.execute(query, package_id)
-          return nil if rows.empty?
-
-          Models::EaPackage.from_db_row(rows.first)
+          database.find_package(package_id)
         end
 
         # Load diagram objects for a diagram
@@ -85,11 +81,8 @@ module Lutaml
         def load_diagram_objects(diagram_id)
           return [] if diagram_id.nil?
 
-          query = "SELECT * FROM t_diagramobjects WHERE Diagram_ID = ?"
-          rows = database.connection.execute(query, diagram_id)
-
-          rows.filter_map do |row|
-            ea_obj = Models::EaDiagramObject.from_db_row(row)
+          ea_objects = database.diagram_objects_for(diagram_id)
+          ea_objects.filter_map do |ea_obj|
             transform_diagram_object(ea_obj)
           end
         end
@@ -127,11 +120,8 @@ module Lutaml
         def load_diagram_links(diagram_id)
           return [] if diagram_id.nil?
 
-          query = "SELECT * FROM t_diagramlinks WHERE DiagramID = ?"
-          rows = database.connection.execute(query, diagram_id)
-
-          rows.filter_map do |row|
-            ea_link = Models::EaDiagramLink.from_db_row(row)
+          ea_links = database.diagram_links_for(diagram_id)
+          ea_links.filter_map do |ea_link|
             transform_diagram_link(ea_link)
           end
         end
@@ -167,11 +157,7 @@ module Lutaml
         def find_connector_by_id(connector_id)
           return nil if connector_id.nil?
 
-          query = "SELECT * FROM t_connector WHERE Connector_ID = ?"
-          rows = database.connection.execute(query, connector_id)
-          return nil if rows.empty?
-
-          Models::EaConnector.from_db_row(rows.first)
+          database.find_connector(connector_id)
         end
       end
     end

data/lib/lutaml/qea/factory/document_builder.rb

@@ -268,7 +268,7 @@ module Lutaml
         end
 
         # Custom validation error
-        class ValidationError < StandardError; end
+        class ValidationError < Lutaml::Error; end
       end
     end
   end

data/lib/lutaml/qea/factory/enum_transformer.rb

@@ -50,12 +50,10 @@ module Lutaml
         def load_enum_values(object_id) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
           return [] if object_id.nil?
 
-          query = "SELECT * FROM t_attribute WHERE Object_ID = ? ORDER BY Pos"
-          rows = database.connection.execute(query, object_id)
-
-          rows.filter_map do |row|
-            ea_attr = Models::EaAttribute.from_db_row(row)
+          ea_attrs = database.attributes_for_object(object_id)
+            .sort_by { |a| a.pos || 0 }
 
+          ea_attrs.filter_map do |ea_attr|
             Lutaml::Uml::Value.new.tap do |value|
               value.name = ea_attr.name
               value.id = normalize_guid_to_xmi_format(ea_attr.ea_guid, "EAID")

data/lib/lutaml/qea/factory/generalization_transformer.rb

@@ -72,11 +72,7 @@ module Lutaml
         def find_object(object_id)
           return nil if object_id.nil?
 
-          query = "SELECT * FROM t_object WHERE Object_ID = ?"
-          rows = database.connection.execute(query, object_id)
-          return nil if rows.empty?
-
-          Models::EaObject.from_db_row(rows.first)
+          database.find_object(object_id)
         end
 
         # Find package by ID
@@ -84,9 +80,8 @@ module Lutaml
         # @return [EaPackage, nil] EA package or nil if not found
         def find_package(package_id)
           return nil if package_id.nil?
-          return nil unless database.packages
 
-          database.packages.find { |pkg| pkg.package_id == package_id }
+          database.find_package(package_id)
         end
 
         # Extract package prefix from package

data/lib/lutaml/qea/factory/instance_transformer.rb

@@ -54,11 +54,7 @@ module Lutaml
         def find_classifier(classifier_id)
           return nil if classifier_id.nil? || classifier_id.zero?
 
-          query = "SELECT * FROM t_object WHERE Object_ID = ?"
-          rows = database.connection.execute(query, classifier_id)
-          return nil if rows.empty?
-
-          Models::EaObject.from_db_row(rows.first)
+          database.find_object(classifier_id)
         end
 
         # Find classifier object by GUID
@@ -67,11 +63,7 @@ module Lutaml
         def find_classifier_by_guid(classifier_guid)
           return nil if classifier_guid.nil? || classifier_guid.empty?
 
-          query = "SELECT * FROM t_object WHERE ea_guid = ?"
-          rows = database.connection.execute(query, classifier_guid)
-          return nil if rows.empty?
-
-          Models::EaObject.from_db_row(rows.first)
+          database.find_object_by_guid(classifier_guid)
         end
 
         # Load and transform tagged values for an instance

data/lib/lutaml/qea/factory/operation_transformer.rb

@@ -60,14 +60,8 @@ module Lutaml
         def load_parameters(operation_id)
           return [] if operation_id.nil?
 
-          # Query t_operationparams table
-          query = "SELECT * FROM t_operationparams WHERE OperationID = ? " \
-                  "ORDER BY Pos"
-          rows = database.connection.execute(query, operation_id)
-
-          rows.map do |row|
-            Models::EaOperationParam.from_db_row(row)
-          end
+          database.operation_params_for(operation_id)
+            .sort_by { |p| p.pos || 0 }
         end
       end
     end

data/lib/lutaml/qea/factory/package_transformer.rb

@@ -70,11 +70,8 @@ module Lutaml
         def load_child_packages(parent_id)
           return [] if parent_id.nil?
 
-          query = "SELECT * FROM t_package WHERE Parent_ID = ? " \
-                  "ORDER BY TPos"
-          rows = database.connection.execute(query, parent_id)
-
-          rows.map { |row| Models::EaPackage.from_db_row(row) }
+          database.child_packages_for(parent_id)
+            .sort_by { |p| p.tpos || 0 }
         end
 
         # Load package contents (objects and diagrams)
@@ -94,10 +91,7 @@ module Lutaml
         # @param pkg [Lutaml::Uml::Package] UML package
         # @param package_id [Integer] Package ID
         def load_package_objects(pkg, package_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          query = "SELECT * FROM t_object WHERE Package_ID = ?"
-          rows = database.connection.execute(query, package_id)
-
-          ea_objects = rows.map { |row| Models::EaObject.from_db_row(row) }
+          ea_objects = database.objects_in_package(package_id)
 
           class_transformer = ClassTransformer.new(database)
           enum_transformer = EnumTransformer.new(database)
@@ -155,10 +149,7 @@ module Lutaml
         def load_package_diagrams(pkg, package_id)
           diagram_transformer = DiagramTransformer.new(database)
 
-          query = "SELECT * FROM t_diagram WHERE Package_ID = ?"
-          rows = database.connection.execute(query, package_id)
-
-          ea_diagrams = rows.map { |row| Models::EaDiagram.from_db_row(row) }
+          ea_diagrams = database.diagrams_in_package(package_id)
           pkg.diagrams = diagram_transformer.transform_collection(ea_diagrams)
         end
 

data/lib/lutaml/qea/repositories/base_repository.rb

@@ -118,8 +118,8 @@ module Lutaml
         # @example
         #   repository.find_first(name: "Test")
         #   repository.find_first { |r| r.name.start_with?("Test") }
-        def find_first(conditions = nil, &block)
-          where(conditions, &block).first
+        def find_first(conditions = nil, &)
+          where(conditions, &).first
         end
 
         # Check if any records match conditions
@@ -127,8 +127,8 @@ module Lutaml
         # @param conditions [Hash, nil] Optional conditions
         # @yield [record] Optional block for custom filtering
         # @return [Boolean] true if any records match
-        def any?(conditions = nil, &block)
-          !where(conditions, &block).empty?
+        def any?(conditions = nil, &)
+          !where(conditions, &).empty?
         end
 
         # Check if no records match conditions
@@ -136,8 +136,8 @@ module Lutaml
         # @param conditions [Hash, nil] Optional conditions
         # @yield [record] Optional block for custom filtering
         # @return [Boolean] true if no records match
-        def none?(conditions = nil, &block)
-          where(conditions, &block).empty?
+        def none?(conditions = nil, &)
+          where(conditions, &).empty?
         end
 
         # Select specific attributes from records

data/lib/lutaml/qea/validation/base_validator.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require_relative "validation_result"
 
 module Lutaml
@@ -233,8 +232,8 @@ module Lutaml
         # @param entities [Array] Collection of entities to validate
         # @yield [entity] Validation block for each entity
         # @return [ValidationResult]
-        def validate_each(entities, &block)
-          entities.each(&block)
+        def validate_each(entities, &)
+          entities.each(&)
           @result
         end
 

data/lib/lutaml/qea/validation/validation_message.rb

@@ -134,9 +134,9 @@ module Lutaml
         # Returns a JSON representation of the message
         #
         # @return [String]
-        def to_json(*args)
+        def to_json(*)
           require "json"
-          to_h.to_json(*args)
+          to_h.to_json(*)
         end
       end
     end

data/lib/lutaml/qea/validation/validation_result.rb

@@ -202,9 +202,9 @@ module Lutaml
         # Returns a JSON representation
         #
         # @return [String]
-        def to_json(*args)
+        def to_json(*)
           require "json"
-          to_h.to_json(*args)
+          to_h.to_json(*)
         end
       end
     end

data/lib/lutaml/sysml.rb

@@ -5,7 +5,7 @@ require "nokogiri"
 
 module Lutaml
   module Sysml
-    class Error < StandardError; end
+    class Error < Lutaml::Error; end
     # Your code goes here...
   end
 end

data/lib/lutaml/uml/has_members.rb

@@ -3,7 +3,7 @@
 module Lutaml
   module Uml
     module HasMembers
-      class UnknownMemberTypeError < StandardError; end
+      class UnknownMemberTypeError < Lutaml::Error; end
 
       # TODO: move to Parslet::Transform
       def members=(value) # rubocop:disable Metrics/AbcSize

data/lib/lutaml/uml/parsers/dsl.rb

@@ -10,7 +10,7 @@ require "lutaml/converter/dsl_to_uml"
 module Lutaml
   module Uml
     module Parsers
-      class ParsingError < StandardError; end
+      class ParsingError < Lutaml::Error; end
 
       # Class for parsing LutaML dsl into Lutaml::Uml::Document
       class Dsl < Parslet::Parser

data/lib/lutaml/uml.rb

@@ -4,7 +4,7 @@ require "lutaml/model"
 
 module Lutaml
   module Uml
-    class Error < StandardError; end
+    class Error < Lutaml::Error; end
 
     # Base modules and mixins
     autoload :HasAttributes, "lutaml/uml/has_attributes"

data/lib/lutaml/uml_repository/index_builder.rb

@@ -42,18 +42,8 @@ module Lutaml
       #   - :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) # rubocop:disable Metrics/MethodLength
-        {
-          package_paths: build_package_paths(document),
-          qualified_names: build_qualified_names(document),
-          stereotypes: build_stereotypes(document),
-          inheritance_graph: build_inheritance_graph(document, nil),
-          diagram_index: build_diagram_index(document, nil),
-          package_to_path: build_package_to_path(document),
-          class_to_qname: build_class_to_qname(document),
-          classes: build_classes(document),
-          associations: build_associations(document),
-        }.freeze
+      def self.build_all(document)
+        new(document).build_all
       end
 
       # Build package paths index
@@ -160,6 +150,8 @@ module Lutaml
         @class_to_qname = {}
         @classes = {}
         @associations = {}
+        @simple_name_to_qnames = {}
+        @package_to_classes = {}
       end
 
       # Build all indexes and return them as a frozen hash
@@ -183,6 +175,7 @@ module Lutaml
           class_to_qname: @class_to_qname.freeze,
           classes: @classes.freeze,
           associations: @associations.freeze,
+          package_to_classes: plain_hash(@package_to_classes).freeze,
         }.freeze
       end
 
@@ -358,6 +351,9 @@ module Lutaml
               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
 
@@ -466,12 +462,18 @@ module Lutaml
         local_qname = "#{current_package_path}::#{name}"
         return local_qname if @qualified_names.key?(local_qname)
 
-        # Try to find in all qualified names (simple name match)
-        @qualified_names.each_key do |qname|
-          return qname if qname.end_with?("::#{name}")
-        end
+        # O(1) lookup using reverse index instead of O(n) scan
+        candidates = @simple_name_to_qnames[name]
+        candidates&.first
+      end
 
-        nil
+      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