lutaml 0.9.43 → 0.10.0

data/lib/lutaml/qea/database.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require_relative "repositories/object_repository"
+
+module Lutaml
+  module Qea
+    # Database container for all loaded EA models
+    #
+    # This class provides a unified container for all EA table collections
+    # loaded from a QEA database. It stores collections by name and provides
+    # accessor methods, statistics, and lookup functionality.
+    #
+    # @example Load and access database
+    #   database = Lutaml::Qea::Services::DatabaseLoader.new("file.qea").load
+    #   puts database.stats
+    #   # => {"objects" => 693, "attributes" => 1910, ...}
+    #
+    #   classes = database.objects.find_by_type("Class")
+    #   obj = database.find_object(123)
+    class Database
+      # @return [Hash<Symbol, Array>] Collections of records by name
+      attr_reader :collections
+
+      # @return [String] Path to the QEA file
+      attr_reader :qea_path
+
+      # @return [SQLite3::Database, nil] Database connection
+      attr_reader :connection
+
+      def initialize(qea_path, connection = nil)
+        @qea_path = qea_path
+        @connection = connection
+        @collections = {}
+        @mutex = Mutex.new
+      end
+
+      # Set database connection
+      #
+      # @param connection [SQLite3::Database] Database connection
+      # @return [void]
+      def connection=(connection)
+        @connection = connection
+      end
+
+      # Add a collection to the database
+      #
+      # @param name [Symbol, String] Collection name (e.g., :objects)
+      # @param records [Array] Array of model instances
+      # @return [void]
+      def add_collection(name, records)
+        @mutex.synchronize do
+          @collections[name.to_sym] = records.freeze
+        end
+      end
+
+      # Get objects collection
+      #
+      # @return [Repositories::ObjectRepository] Repository for objects
+      def objects
+        return @objects if defined?(@objects)
+
+        @objects = Repositories::ObjectRepository.new(
+          @collections[:objects] || [],
+        )
+      end
+
+      # Get attributes collection
+      #
+      # @return [Array<Models::EaAttribute>] Array of attributes
+      def attributes
+        @collections[:attributes] || []
+      end
+
+      # Get operations collection
+      #
+      # @return [Array<Models::EaOperation>] Array of operations
+      def operations
+        @collections[:operations] || []
+      end
+
+      # Get operation parameters collection
+      #
+      # @return [Array<Models::EaOperationParam>] Array of operation parameters
+      def operation_params
+        @collections[:operation_params] || []
+      end
+
+      # Get connectors collection
+      #
+      # @return [Array<Models::EaConnector>] Array of connectors
+      def connectors
+        @collections[:connectors] || []
+      end
+
+      # Get packages collection
+      #
+      # @return [Array<Models::EaPackage>] Array of packages
+      def packages
+        @collections[:packages] || []
+      end
+
+      # Get diagrams collection
+      #
+      # @return [Array<Models::EaDiagram>] Array of diagrams
+      def diagrams
+        @collections[:diagrams] || []
+      end
+
+      # Get diagram objects collection (visual placement)
+      #
+      # @return [Array<Models::EaDiagramObject>] Array of diagram objects
+      def diagram_objects
+        @collections[:diagram_objects] || []
+      end
+
+      # Get diagram links collection (visual routing)
+      #
+      # @return [Array<Models::EaDiagramLink>] Array of diagram links
+      def diagram_links
+        @collections[:diagram_links] || []
+      end
+
+      # Get object constraints collection
+      #
+      # @return [Array<Models::EaObjectConstraint>] Array of object
+      #   constraints
+      def object_constraints
+        @collections[:object_constraints] || []
+      end
+
+      # Get tagged values collection
+      #
+      # @return [Array<Models::EaTaggedValue>] Array of tagged values
+      def tagged_values
+        @collections[:tagged_values] || []
+      end
+
+      # Get object properties collection
+      #
+      # @return [Array<Models::EaObjectProperty>] Array of object properties
+      def object_properties
+        @collections[:object_properties] || []
+      end
+
+      # Get attribute tags collection
+      #
+      # @return [Array<Models::EaAttributeTag>] Array of attribute tags
+      def attribute_tags
+        @collections[:attribute_tags] || []
+      end
+
+      # Get cross-references collection
+      #
+      # @return [Array<Models::EaXref>] Array of cross-references
+      def xrefs
+        @collections[:xrefs] || []
+      end
+
+      # Get stereotypes collection
+      #
+      # @return [Array<Models::EaStereotype>] Array of stereotype definitions
+      def stereotypes
+        @collections[:stereotypes] || []
+      end
+
+      # Get datatypes collection
+      #
+      # @return [Array<Models::EaDatatype>] Array of datatype definitions
+      def datatypes
+        @collections[:datatypes] || []
+      end
+
+      # Get constraint types collection (Priority 3 lookup table)
+      #
+      # @return [Array<Models::EaConstraintType>] Array of constraint type
+      #   definitions
+      def constraint_types
+        @collections[:constraint_types] || []
+      end
+
+      # Get connector types collection (Priority 3 lookup table)
+      #
+      # @return [Array<Models::EaConnectorType>] Array of connector type
+      #   definitions
+      def connector_types
+        @collections[:connector_types] || []
+      end
+
+      # Get diagram types collection (Priority 3 lookup table)
+      #
+      # @return [Array<Models::EaDiagramType>] Array of diagram type
+      #   definitions
+      def diagram_types
+        @collections[:diagram_types] || []
+      end
+
+      # Get object types collection (Priority 3 lookup table)
+      #
+      # @return [Array<Models::EaObjectType>] Array of object type definitions
+      def object_types
+        @collections[:object_types] || []
+      end
+
+      # Get status types collection (Priority 3 lookup table)
+      #
+      # @return [Array<Models::EaStatusType>] Array of status type definitions
+      def status_types
+        @collections[:status_types] || []
+      end
+
+      # Get complexity types collection (Priority 3 lookup table)
+      #
+      # @return [Array<Models::EaComplexityType>] Array of complexity type
+      #   definitions
+      def complexity_types
+        @collections[:complexity_types] || []
+      end
+
+      # Get documents collection (Priority 4)
+      #
+      # @return [Array<Models::EaDocument>] Array of document artifacts
+      def documents
+        @collections[:documents] || []
+      end
+
+      # Get scripts collection (Priority 4)
+      #
+      # @return [Array<Models::EaScript>] Array of behavioral scripts
+      def scripts
+        @collections[:scripts] || []
+      end
+
+      # Get statistics for all collections
+      #
+      # @return [Hash<String, Integer>] Record counts by collection name
+      #
+      # @example
+      #   database.stats
+      #   # => {
+      #   #   "objects" => 693,
+      #   #   "attributes" => 1910,
+      #   #   "connectors" => 908,
+      #   #   ...
+      #   # }
+      def stats
+        @collections.each_with_object({}) do |(name, records), hash|
+          hash[name.to_s] = records.size
+        end
+      end
+
+      # Get total number of records across all collections
+      #
+      # @return [Integer] Total record count
+      def total_records
+        @collections.values.sum(&:size)
+      end
+
+      # Find an object by ID
+      #
+      # @param id [Integer] Object ID
+      # @return [Models::EaObject, nil] The object or nil if not found
+      def find_object(id)
+        objects.find_by_key(:ea_object_id, id)
+      end
+
+      # Find a package by ID
+      #
+      # @param id [Integer] Package ID
+      # @return [Models::EaPackage, nil] The package or nil if not found
+      def find_package(id)
+        packages.find { |pkg| pkg.package_id == id }
+      end
+
+      # Find an attribute by ID
+      #
+      # @param id [Integer] Attribute ID
+      # @return [Models::EaAttribute, nil] The attribute or nil if not found
+      def find_attribute(id)
+        attributes.find { |attr| attr.id == id }
+      end
+
+      # Find a connector by ID
+      #
+      # @param id [Integer] Connector ID
+      # @return [Models::EaConnector, nil] The connector or nil if not found
+      def find_connector(id)
+        connectors.find { |conn| conn.connector_id == id }
+      end
+
+      # Find a diagram by ID
+      #
+      # @param id [Integer] Diagram ID
+      # @return [Models::EaDiagram, nil] The diagram or nil if not found
+      def find_diagram(id)
+        diagrams.find { |diag| diag.diagram_id == id }
+      end
+
+      # Check if database is empty
+      #
+      # @return [Boolean] true if no collections loaded
+      def empty?
+        @collections.empty? || total_records.zero?
+      end
+
+      # Get collection names
+      #
+      # @return [Array<Symbol>] Array of collection names
+      def collection_names
+        @collections.keys
+      end
+
+      # Freeze all collections to make database immutable
+      #
+      # @return [self]
+      def freeze
+        # Memoize repositories before freezing
+        objects
+
+        @collections.freeze
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "base_transformer"
+require_relative "tagged_value_transformer"
+require "lutaml/uml"
+
+module Lutaml
+  module Qea
+    module Factory
+      # Transforms EA connectors (Association type) to UML associations
+      class AssociationTransformer < BaseTransformer
+        # Transform EA connector to UML association
+        # @param ea_connector [EaConnector] EA connector model
+        # @return [Lutaml::Uml::Association] UML association
+        def transform(ea_connector) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return nil if ea_connector.nil?
+          return nil unless ea_connector.association?
+
+          Lutaml::Uml::Association.new.tap do |assoc| # rubocop:disable Metrics/BlockLength
+            # Map basic properties
+            assoc.name = ea_connector.name unless
+              ea_connector.name.nil? || ea_connector.name.empty?
+            assoc.xmi_id = normalize_guid_to_xmi_format(ea_connector.ea_guid,
+                                                        "EAID")
+
+            # Map source (owner) end
+            source_obj = find_object(ea_connector.start_object_id)
+            if source_obj
+              assoc.owner_end = source_obj.name
+              assoc.owner_end_xmi_id = normalize_guid_to_xmi_format(
+                source_obj.ea_guid, "EAID"
+              )
+              assoc.owner_end_attribute_name = ea_connector.sourcerole
+              assoc.owner_end_cardinality = build_cardinality_from_string(
+                ea_connector.sourcecard,
+              )
+            end
+
+            # Map target (member) end
+            target_obj = find_object(ea_connector.end_object_id)
+            if target_obj
+              assoc.member_end = target_obj.name
+              assoc.member_end_xmi_id = normalize_guid_to_xmi_format(
+                target_obj.ea_guid, "EAID"
+              )
+              assoc.member_end_attribute_name = ea_connector.destrole
+              assoc.member_end_cardinality = build_cardinality_from_string(
+                ea_connector.destcard,
+              )
+            end
+
+            # Map definition/notes
+            assoc.definition = ea_connector.notes unless
+              ea_connector.notes.nil? || ea_connector.notes.empty?
+
+            # Map stereotype
+            if ea_connector.stereotype && !ea_connector.stereotype.empty?
+              assoc.stereotype = [ea_connector.stereotype]
+            end
+
+            # Load and transform tagged values
+            assoc.tagged_values = load_tagged_values(ea_connector.ea_guid)
+          end
+        end
+
+        private
+
+        # Find object by ID
+        # @param object_id [Integer] Object ID
+        # @return [EaObject, nil] EA object or nil if not found
+        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)
+        end
+
+        # Build cardinality from string
+        # @param cardinality_str [String] Cardinality string
+        # @return [Lutaml::Uml::Cardinality, nil] Cardinality object
+        def build_cardinality_from_string(cardinality_str)
+          return nil if cardinality_str.nil? || cardinality_str.empty?
+
+          parsed = parse_cardinality(cardinality_str)
+          return nil if parsed[:min].nil? && parsed[:max].nil?
+
+          Lutaml::Uml::Cardinality.new.tap do |card|
+            card.min = parsed[:min]
+            card.max = parsed[:max]
+          end
+        end
+
+        # Load and transform tagged values for an association
+        # @param ea_guid [String] Element GUID
+        # @return [Array<Lutaml::Uml::TaggedValue>] UML tagged values
+        def load_tagged_values(ea_guid)
+          return [] if ea_guid.nil?
+          return [] unless database.tagged_values
+
+          # Filter tagged values for this element from the in-memory collection
+          ea_tags = database.tagged_values.select do |tag|
+            tag.element_id == ea_guid
+          end
+
+          # Transform to UML tagged values
+          tag_transformer = TaggedValueTransformer.new(database)
+          tag_transformer.transform_collection(ea_tags)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "base_transformer"
+require "lutaml/uml"
+
+module Lutaml
+  module Qea
+    module Factory
+      # Transforms EA AttributeTag to UML TaggedValue
+      #
+      # This transformer converts Enterprise Architect attribute tags
+      # (GML/XML Schema encoding metadata for attributes) to UML
+      # TaggedValue objects.
+      #
+      # @example Transform an attribute tag
+      #   ea_tag = Models::EaAttributeTag.new(
+      #     property_id: 1,
+      #     element_id: 367,
+      #     property: "isMetadata",
+      #     value: "false"
+      #   )
+      #   transformer = AttributeTagTransformer.new
+      #   uml_tag = transformer.transform(ea_tag)
+      class AttributeTagTransformer < BaseTransformer
+        # Transform EA attribute tag to UML TaggedValue
+        #
+        # Attribute tags enhance UML attributes with GML/XML encoding
+        # metadata. They are transformed into tagged values to preserve
+        # this semantic information.
+        #
+        # @param ea_tag [Models::EaAttributeTag] EA attribute tag
+        # @return [Lutaml::Uml::TaggedValue, nil] UML tagged value or nil
+        def transform(ea_tag)
+          return nil unless ea_tag
+          return nil unless ea_tag.property
+
+          Lutaml::Uml::TaggedValue.new.tap do |tag|
+            tag.name = ea_tag.property
+            tag.value = ea_tag.value || ""
+            tag.notes = format_notes(ea_tag)
+          end
+        end
+
+        private
+
+        # Format notes from EA attribute tag
+        #
+        # @param ea_tag [Models::EaAttributeTag] EA tag
+        # @return [String, nil] Formatted notes
+        def format_notes(ea_tag)
+          return nil unless ea_tag.notes
+
+          # Clean up EA's note format
+          notes = ea_tag.notes.strip
+          notes.empty? ? nil : notes
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "base_transformer"
+require_relative "attribute_tag_transformer"
+require "lutaml/uml"
+
+module Lutaml
+  module Qea
+    module Factory
+      # Transforms EA attributes to UML attributes
+      class AttributeTransformer < BaseTransformer
+        # Transform EA attribute to UML attribute
+        # @param ea_attribute [EaAttribute] EA attribute model
+        # @return [Lutaml::Uml::TopElementAttribute] UML attribute
+        def transform(ea_attribute) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return nil if ea_attribute.nil?
+
+          Lutaml::Uml::TopElementAttribute.new.tap do |attr|
+            attr.name = ea_attribute.name
+            attr.type = ea_attribute.type
+            attr.visibility = map_visibility(ea_attribute.scope)
+
+            # XMI uses the TYPE's XMI ID, not the attribute's ID
+            type_xmi_id = lookup_type_xmi_id(ea_attribute.classifier)
+            attr.xmi_id = type_xmi_id || normalize_guid_to_xmi_format(
+              ea_attribute.ea_guid, "EAID"
+            )
+
+            attr.id = normalize_guid_to_xmi_format(ea_attribute.ea_guid, "EAID")
+            attr.static = ea_attribute.static? ? "true" : nil
+            attr.is_derived = ea_attribute.derived == "1"
+
+            # Map cardinality if bounds are present
+            if ea_attribute.lowerbound || ea_attribute.upperbound
+              attr.cardinality = build_cardinality(
+                ea_attribute.lowerbound,
+                ea_attribute.upperbound,
+              )
+            end
+
+            # Map definition/notes
+            attr.definition = normalize_line_endings(ea_attribute.notes) unless
+              ea_attribute.notes.nil? || ea_attribute.notes.empty?
+
+            # Load and transform attribute tags
+            attr.tagged_values = load_attribute_tags(ea_attribute.id)
+          end
+        end
+
+        private
+
+        # Look up the type object's XMI ID from classifier
+        # @param classifier_id [Integer] Classifier ID
+        # @return [String, nil] Type's XMI ID
+        def lookup_type_xmi_id(classifier_id) # rubocop:disable Metrics/AbcSize
+          return nil if classifier_id.nil? || classifier_id.to_i.zero?
+
+          query = "SELECT ea_guid FROM t_object WHERE Object_ID = ?"
+          rows = database.connection.execute(query, [classifier_id])
+          return nil if rows.empty?
+
+          ea_guid = if rows.first.is_a?(Hash)
+                      rows.first["ea_guid"] || rows.first[:ea_guid]
+                    else
+                      rows.first[0]
+                    end
+          normalize_guid_to_xmi_format(ea_guid, "EAID")
+        end
+
+        # Build cardinality from lower and upper bounds
+        # @param lower [String] Lower bound
+        # @param upper [String] Upper bound
+        # @return [Lutaml::Uml::Cardinality] Cardinality object
+        def build_cardinality(lower, upper)
+          return nil if lower.nil? && upper.nil?
+
+          Lutaml::Uml::Cardinality.new.tap do |card|
+            card.min = lower || "0"
+            card.max = upper || "*"
+          end
+        end
+
+        # Load and transform attribute tags for an attribute
+        # @param attribute_id [Integer] Attribute ID
+        # @return [Array<Lutaml::Uml::TaggedValue>] UML tagged values
+        def load_attribute_tags(attribute_id)
+          return [] if attribute_id.nil?
+          return [] unless database.attribute_tags
+
+          # Filter attribute tags for this attribute from the in-memory
+          # collection
+          ea_tags = database.attribute_tags.select do |tag|
+            tag.element_id == attribute_id
+          end
+
+          # Transform to UML tagged values
+          tag_transformer = AttributeTagTransformer.new(database)
+          tag_transformer.transform_collection(ea_tags)
+        end
+      end
+    end
+  end
+end