ea 0.1.0 → 0.1.4

data/lib/ea/qea/database.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Ea
+  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 = Ea::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
+
+      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
+
+      # Close the database connection if open
+      # @return [void]
+      def close_connection
+        return unless @connection && !@connection.closed?
+
+        @connection.close
+      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
+
+      COLLECTION_ACCESSORS = %i[
+        attributes operations operation_params connectors packages
+        diagrams diagram_objects diagram_links object_constraints
+        tagged_values object_properties attribute_tags xrefs
+        stereotypes datatypes constraint_types connector_types
+        diagram_types object_types status_types complexity_types
+        documents scripts
+      ].freeze
+
+      COLLECTION_ACCESSORS.each do |name|
+        define_method(name) do
+          @collections[name] || []
+        end
+      end
+
+      # Get objects collection (special: wrapped in ObjectRepository)
+      #
+      # @return [Repositories::ObjectRepository] Repository for objects
+      def objects
+        return @objects if defined?(@objects)
+
+        @objects = Repositories::ObjectRepository.new(
+          @collections[:objects] || [],
+        )
+      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
+
+      def find_package(id)
+        ensure_lookup_indexes
+        @packages_by_id[id]
+      end
+
+      def find_attribute(id)
+        ensure_lookup_indexes
+        @attributes_by_id[id]
+      end
+
+      def find_connector(id)
+        ensure_lookup_indexes
+        @connectors_by_id[id]
+      end
+
+      def find_diagram(id)
+        ensure_lookup_indexes
+        @diagrams_by_id[id]
+      end
+
+      def attributes_for_object(id)
+        ensure_lookup_indexes
+        @attributes_by_object_id[id] || []
+      end
+
+      def operations_for_object(id)
+        ensure_lookup_indexes
+        @operations_by_object_id[id] || []
+      end
+
+      def operation_params_for(id)
+        ensure_lookup_indexes
+        @operation_params_by_id[id] || []
+      end
+
+      def child_packages_for(id)
+        ensure_lookup_indexes
+        @packages_by_parent[id] || []
+      end
+
+      def objects_in_package(id)
+        ensure_lookup_indexes
+        @objects_by_package_id[id] || []
+      end
+
+      def diagrams_in_package(id)
+        ensure_lookup_indexes
+        @diagrams_by_package_id[id] || []
+      end
+
+      def diagram_objects_for(id)
+        ensure_lookup_indexes
+        @diagram_objects_by_id[id] || []
+      end
+
+      def diagram_links_for(id)
+        ensure_lookup_indexes
+        @diagram_links_by_id[id] || []
+      end
+
+      # Find an object by ID
+      def find_object(id)
+        objects.find_by_key(:ea_object_id, id)
+      end
+
+      # Find object by ea_guid
+      def find_object_by_guid(ea_guid)
+        ensure_lookup_indexes
+        @objects_by_guid[ea_guid]
+      end
+
+      # Get connectors involving a specific object (start or end)
+      def connectors_for_object(object_id)
+        ensure_lookup_indexes
+        @connectors_by_object[object_id] || []
+      end
+
+      def constraints_for_object(object_id)
+        ensure_lookup_indexes
+        @constraints_by_object_id[object_id] || []
+      end
+
+      def tagged_values_for_element(ea_guid)
+        ensure_lookup_indexes
+        @tagged_values_by_element_id[ea_guid] || []
+      end
+
+      def properties_for_object(object_id)
+        ensure_lookup_indexes
+        @properties_by_object_id[object_id] || []
+      end
+
+      def xrefs_for_client(ea_guid)
+        ensure_lookup_indexes
+        @xrefs_by_client[ea_guid] || []
+      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
+        objects
+        ensure_lookup_indexes
+        @collections.freeze
+        super
+      end
+
+      private
+
+      def ensure_lookup_indexes
+        return if @lookup_indexes_built
+
+        build_lookup_indexes
+        @lookup_indexes_built = true
+      end
+
+      def build_group_index(collection, method, single: false)
+        collection.each_with_object({}) do |item, hash|
+          key = item.public_send(method)
+          next unless key
+
+          single ? (hash[key] = item) : ((hash[key] ||= []) << item)
+        end
+      end
+
+      def build_lookup_indexes
+        build_primary_indexes
+        build_secondary_indexes
+      end
+
+      def build_primary_indexes
+        build_object_indexes
+        build_feature_indexes
+        build_connector_indexes
+        build_diagram_indexes
+      end
+
+      def build_object_indexes
+        @objects_by_guid = build_group_index(objects, :ea_guid, single: true)
+        @objects_by_package_id = build_group_index(objects, :package_id)
+        @packages_by_parent = build_group_index(packages, :parent_id)
+      end
+
+      def build_feature_indexes
+        @attributes_by_object_id = build_group_index(attributes, :ea_object_id)
+        @operations_by_object_id = build_group_index(operations, :ea_object_id)
+        @operation_params_by_id = build_group_index(operation_params,
+                                                    :operationid)
+      end
+
+      def build_connector_indexes
+        @connectors_by_start = build_group_index(connectors, :start_object_id)
+        @connectors_by_end = build_group_index(connectors, :end_object_id)
+        @connectors_by_object = {}
+        @connectors_by_start.each do |id, conns|
+          (@connectors_by_object[id] ||= []).concat(conns)
+        end
+        @connectors_by_end.each do |id, conns|
+          (@connectors_by_object[id] ||= []).concat(conns)
+        end
+      end
+
+      def build_diagram_indexes
+        @diagrams_by_package_id = build_group_index(diagrams, :package_id)
+        @diagram_objects_by_id = build_group_index(diagram_objects, :diagram_id)
+        @diagram_links_by_id = build_group_index(diagram_links, :diagramid)
+      end
+
+      def build_secondary_indexes
+        @packages_by_id = build_group_index(packages, :package_id, single: true)
+        @connectors_by_id = build_group_index(connectors, :connector_id,
+                                              single: true)
+        @diagrams_by_id = build_group_index(diagrams, :diagram_id, single: true)
+        @attributes_by_id = build_group_index(attributes, :id, single: true)
+        @constraints_by_object_id = build_group_index(object_constraints,
+                                                      :ea_object_id)
+        @tagged_values_by_element_id = build_group_index(tagged_values,
+                                                         :element_id)
+        @properties_by_object_id = build_group_index(object_properties,
+                                                     :ea_object_id)
+        @xrefs_by_client = build_group_index(xrefs, :client)
+      end
+    end
+  end
+end

data/lib/ea/qea/factory/association_builder.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      class AssociationBuilder < BaseTransformer
+        ASSOC_TYPES = ["Association", "Aggregation", "Composition"].freeze
+
+        def load_class_associations(object_id, object_guid)
+          return [] if object_id.nil?
+
+          normalized_owner_xmi_id = normalize_guid_to_xmi_format(object_guid,
+                                                                 "EAID")
+
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| ASSOC_TYPES.include?(c.connector_type) }
+
+          assoc_connectors.filter_map do |ea_connector|
+            build_association(ea_connector, object_id, normalized_owner_xmi_id)
+          end
+        end
+
+        def load_association_attributes(object_id)
+          return [] if object_id.nil?
+
+          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)
+
+          assoc_connectors.filter_map do |ea_connector|
+            build_connector_attribute(ea_connector, object_id, obj,
+                                      obj_pkg_name)
+          end
+        end
+
+        def build_connector_attribute(ea_connector, object_id, obj,
+obj_pkg_name)
+          if ea_connector.start_object_id == object_id
+            build_end_attribute(ea_connector, obj, obj_pkg_name)
+          elsif ea_connector.end_object_id == object_id
+            build_start_attribute(ea_connector, obj, obj_pkg_name)
+          end
+        end
+
+        def create_association_attribute( # rubocop:disable Metrics/ParameterLists
+          name:, type:, type_xmi_id:,
+          association_xmi_id:, cardinality:, definition:,
+          gen_name:, name_ns:, type_ns:, is_src: true
+        )
+          Lutaml::Uml::GeneralAttribute.new.tap do |attr|
+            assign_assoc_attr_basic(attr, name, type, gen_name, definition,
+                                    name_ns, type_ns)
+            attr.xmi_id = normalize_guid_to_xmi_format(type_xmi_id, "EAID")
+            attr.association = normalize_guid_to_xmi_format(
+              association_xmi_id, "EAID"
+            )
+            attr.has_association = true
+            attr.id = normalize_guid_to_xmi_src_dst_format(
+              association_xmi_id, "EAID", is_src
+            )
+            attr.cardinality = build_cardinality(cardinality)
+          end
+        end
+
+        private
+
+        def assign_assoc_attr_basic(attr, name, type, gen_name,
+                                    definition, name_ns, type_ns)
+          attr.name = name
+          attr.type = type
+          attr.gen_name = gen_name
+          attr.definition = definition
+          attr.name_ns = name_ns
+          attr.type_ns = type_ns
+        end
+
+        def build_association(ea_connector, object_id, normalized_owner_xmi_id)
+          is_start = ea_connector.start_object_id == object_id
+          owner_role = is_start ? ea_connector.destrole : ea_connector.sourcerole
+          return nil if owner_role.nil? || owner_role.empty?
+
+          member_obj = resolve_member_object(ea_connector, is_start)
+          return nil unless member_obj
+
+          member_role = resolve_member_role(ea_connector, is_start, member_obj)
+
+          build_association_record(ea_connector, object_id, normalized_owner_xmi_id,
+                                   owner_role, member_obj, member_role, is_start)
+        end
+
+        def build_association_record(ea_connector, object_id, owner_xmi_id,
+                                     owner_role, member_obj, member_role, is_start)
+          cardinality_str = is_start ? ea_connector.destcard : ea_connector.sourcecard
+
+          Lutaml::Uml::Association.new.tap do |assoc|
+            assoc.xmi_id = normalize_guid_to_xmi_format(ea_connector.ea_guid,
+                                                        "EAID")
+            assign_assoc_name(assoc, ea_connector)
+            assign_association_ends(assoc, object_id, owner_xmi_id,
+                                    owner_role, member_obj, member_role)
+            assoc.member_end_type = ea_connector.connector_type&.downcase
+            assoc.member_end_cardinality = build_cardinality(cardinality_str)
+          end
+        end
+
+        def assign_assoc_name(assoc, ea_connector)
+          return if ea_connector.name.nil? || ea_connector.name.empty?
+
+          assoc.name = ea_connector.name
+        end
+
+        def assign_association_ends(assoc, object_id, owner_xmi_id,
+                                    owner_role, member_obj, member_role)
+          assoc.owner_end = find_object_by_id(object_id)&.name
+          assoc.owner_end_xmi_id = owner_xmi_id
+          assoc.owner_end_attribute_name = owner_role
+          assoc.member_end = member_obj.name
+          assoc.member_end_xmi_id = normalize_guid_to_xmi_format(
+            member_obj.ea_guid, "EAID"
+          )
+          assoc.member_end_attribute_name = member_role
+        end
+
+        def resolve_member_object(ea_connector, is_start)
+          peer_id = is_start ? ea_connector.end_object_id : ea_connector.start_object_id
+          find_object_by_id(peer_id)
+        end
+
+        def resolve_member_role(ea_connector, is_start, member_obj)
+          role = is_start ? ea_connector.sourcerole : ea_connector.destrole
+          role.nil? || role.empty? ? member_obj.name : role
+        end
+
+        def build_end_attribute(ea_connector, obj, obj_pkg_name)
+          return nil if ea_connector.destrole.nil? || ea_connector.destrole.empty?
+
+          target_obj = find_object_by_id(ea_connector.end_object_id)
+          return nil unless target_obj
+
+          build_directional_attribute(
+            role: ea_connector.destrole,
+            peer_obj: target_obj,
+            ea_connector: ea_connector,
+            cardinality: ea_connector.destcard,
+            obj: obj, obj_pkg_name: obj_pkg_name,
+            is_src: false
+          )
+        end
+
+        def build_start_attribute(ea_connector, obj, obj_pkg_name)
+          return nil if ea_connector.sourcerole.nil? || ea_connector.sourcerole.empty?
+
+          source_obj = find_object_by_id(ea_connector.start_object_id)
+          return nil unless source_obj
+
+          build_directional_attribute(
+            role: ea_connector.sourcerole,
+            peer_obj: source_obj,
+            ea_connector: ea_connector,
+            cardinality: ea_connector.sourcecard,
+            obj: obj, obj_pkg_name: obj_pkg_name
+          )
+        end
+
+        def build_directional_attribute(role:, peer_obj:, ea_connector:,
+                                        cardinality:, obj:, obj_pkg_name:,
+                                        is_src: true)
+          create_association_attribute(
+            name: role,
+            type: peer_obj.name,
+            type_xmi_id: peer_obj.ea_guid,
+            association_xmi_id: ea_connector.ea_guid,
+            cardinality: cardinality,
+            definition: ea_connector.notes,
+            gen_name: obj.name,
+            name_ns: obj_pkg_name,
+            type_ns: find_package_name(peer_obj.package_id),
+            is_src: is_src,
+          )
+        end
+
+        def build_cardinality(cardinality_str)
+          return nil unless cardinality_str && !cardinality_str.empty?
+
+          parsed = parse_cardinality(cardinality_str)
+          return nil unless parsed[:min] || parsed[:max]
+
+          Lutaml::Uml::Cardinality.new.tap do |card|
+            card.min = parsed[:min]
+            card.max = parsed[:max]
+          end
+        end
+
+        def find_package_name(package_id)
+          return nil if package_id.nil?
+
+          database.find_package(package_id)&.name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Ea
+  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?
+
+          database.find_object(object_id)
+        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
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Ea
+  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