ea 0.1.0 → 0.1.4

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

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      class GeneralizationBuilder < BaseTransformer
+        def load_generalization(object_id, visited = Set.new, is_leaf = true) # rubocop:disable Style/OptionalBooleanParameter
+          return nil if object_id.nil?
+          return nil if circular_inheritance?(object_id, visited)
+
+          visited = visited.dup.add(object_id)
+
+          current_obj = find_object_by_id(object_id)
+          return nil unless current_obj
+
+          generalization = build_generalization(object_id, current_obj)
+          return nil unless generalization
+
+          populate_generalization_attrs(generalization, object_id)
+          populate_parent_generalization(generalization,
+                                         ea_connector_for(object_id), visited)
+
+          collect_inherited_properties(generalization) if is_leaf && generalization.has_general
+
+          generalization
+        end
+
+        def circular_inheritance?(object_id, visited)
+          return false unless visited.include?(object_id)
+
+          warn "Circular inheritance detected for object_id #{object_id}, " \
+               "stopping recursion"
+          true
+        end
+
+        def load_association_generalizations(object_id)
+          return [] if object_id.nil?
+
+          gen_connectors = database.connectors_for_object(object_id)
+            .select { |c| c.generalization? && c.start_object_id == object_id }
+
+          gen_connectors.filter_map do |ea_connector|
+            build_assoc_generalization(ea_connector)
+          end
+        end
+
+        def convert_to_general_attributes(attributes)
+          attributes.map { |attr| to_general_attribute(attr) }
+        end
+
+        def convert_to_top_element_attributes(attributes)
+          attributes.map { |attr| to_top_element_attribute(attr) }
+        end
+
+        def to_general_attribute(attr)
+          base = base_attr_hash(attr)
+          Lutaml::Uml::GeneralAttribute.new.tap do |gen_attr|
+            base.each { |k, v| gen_attr.public_send(:"#{k}=", v) }
+            gen_attr.is_derived = !!attr.is_derived
+            gen_attr.has_association = !!attr.association
+          end
+        end
+
+        def to_top_element_attribute(attr)
+          base = base_attr_hash(attr)
+          Lutaml::Uml::TopElementAttribute.new.tap do |top_attr|
+            base.each { |k, v| top_attr.public_send(:"#{k}=", v) }
+            top_attr.is_derived = !!attr.is_derived
+          end
+        end
+
+        def base_attr_hash(attr)
+          {
+            id: attr.id,
+            name: attr.name,
+            type: attr.type,
+            xmi_id: attr.xmi_id,
+            cardinality: attr.cardinality,
+            definition: attr.definition&.strip,
+            association: attr.association,
+            type_ns: attr.type_ns,
+          }
+        end
+
+        private
+
+        def tag_ancestor_attributes(gen, level)
+          [gen.general_attributes, gen.attributes].each do |attr_list|
+            attr_list&.each do |attr|
+              attr.upper_klass = gen.general_upper_klass
+              attr.level = level
+            end
+          end
+        end
+
+        def collect_ancestor_attrs(gen, level, inherited_props,
+                                   inherited_assoc_props)
+          gen.attributes.reverse_each do |attr|
+            inherited_attr = attr.dup
+            inherited_attr.upper_klass = gen.general_upper_klass
+            inherited_attr.gen_name = gen.general_name
+            inherited_attr.level = level
+
+            if attr.has_association
+              inherited_assoc_props << inherited_attr
+            else
+              inherited_props << inherited_attr
+            end
+          end
+        end
+
+        def build_assoc_generalization(ea_connector)
+          parent_obj = find_object_by_id(ea_connector.end_object_id)
+          return nil unless parent_obj
+
+          Lutaml::Uml::AssociationGeneralization.new.tap do |ag|
+            ag.id = normalize_guid_to_xmi_format(ea_connector.ea_guid, "EAID")
+            ag.type = "uml:Generalization"
+            ag.general = normalize_guid_to_xmi_format(parent_obj.ea_guid,
+                                                      "EAID")
+          end
+        end
+
+        def resolve_name_ns(type_ns, upper_klass)
+          ns = case type_ns
+               when "core", "gml"
+                 upper_klass
+               else
+                 type_ns
+               end
+          ns || upper_klass
+        end
+
+        def build_generalization(object_id, current_obj)
+          ea_connector = ea_connector_for(object_id)
+          gen_transformer = GeneralizationTransformer.new(database)
+          if ea_connector.nil?
+            gen_transformer.transform(nil, current_obj)
+          else
+            gen_transformer.transform(ea_connector, current_obj)
+          end
+        end
+
+        def ea_connector_for(object_id)
+          database.connectors_for_object(object_id)
+            .find { |c| c.generalization? && c.start_object_id == object_id }
+        end
+
+        def populate_generalization_attrs(generalization, object_id)
+          general_attrs = build_general_attrs(object_id)
+          apply_namespace_to_attrs(general_attrs, generalization)
+
+          generalization.general_attributes = general_attrs
+            .sort_by { |a| [a.name.to_s, a.id] }
+
+          generalization.attributes = transform_general_attributes(
+            generalization,
+          )
+
+          generalization.owned_props = generalization.attributes
+            .reject(&:has_association)
+          generalization.assoc_props = generalization.attributes
+            .select(&:has_association)
+        end
+
+        def build_general_attrs(object_id)
+          current_attrs = load_attributes(object_id)
+          current_assoc_attrs = AssociationBuilder.new(database)
+            .load_association_attributes(object_id)
+          convert_to_general_attributes(current_attrs + current_assoc_attrs)
+        end
+
+        def apply_namespace_to_attrs(general_attrs, generalization)
+          upper_klass = generalization.general_upper_klass
+          general_attrs.each do |attr|
+            attr.gen_name = generalization.general_name
+            attr.name_ns = resolve_name_ns(attr.type_ns, upper_klass)
+          end
+        end
+
+        def populate_parent_generalization(generalization, ea_connector,
+visited)
+          parent_object_id = ea_connector&.end_object_id
+          return unless parent_object_id
+
+          parent_gen = load_generalization(parent_object_id, visited, false)
+          return unless parent_gen
+
+          generalization.general = parent_gen
+          generalization.has_general = true
+        end
+
+        def transform_general_attributes(generalization)
+          upper_klass = generalization.general_upper_klass
+          gen_name = generalization.general_name
+
+          generalization.general_attributes.map do |attr|
+            transformed = attr.dup
+            transformed.name_ns = resolve_name_ns(attr.type_ns, upper_klass)
+            transformed.gen_name = gen_name
+            transformed.name = "" if transformed.name.nil?
+            transformed
+          end
+        end
+
+        def collect_inherited_properties(generalization)
+          inherited_props = []
+          inherited_assoc_props = []
+          level = 0
+
+          current_gen = generalization.general
+          while current_gen
+            tag_ancestor_attributes(current_gen, level)
+            collect_ancestor_attrs(current_gen, level, inherited_props,
+                                   inherited_assoc_props)
+
+            level += 1
+            current_gen = current_gen.general
+          end
+
+          generalization.inherited_props = inherited_props.reverse
+          generalization.inherited_assoc_props = inherited_assoc_props.reverse
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Transforms EA connectors (Generalization type) to UML generalizations
+      class GeneralizationTransformer < BaseTransformer
+        # Transform EA connector to UML generalization
+        # @param ea_connector [EaConnector, nil]
+        # EA connector model (nil for terminal nodes)
+        # @param current_object [EaObject]
+        # Current object that owns this generalization
+        # @return [Lutaml::Uml::Generalization] UML generalization
+        def transform(ea_connector, current_object) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return nil if current_object.nil?
+
+          # ea_connector can be nil for terminal nodes (classes with no parent)
+          if ea_connector && !ea_connector.generalization?
+            return nil
+          end
+
+          Lutaml::Uml::Generalization.new.tap do |gen| # rubocop:disable Metrics/BlockLength
+            # Map properties from CURRENT object (not parent)
+            # This matches XMI's self-referential pattern
+            gen.general_id = normalize_guid_to_xmi_format(
+              current_object.ea_guid, "EAID"
+            )
+            gen.general_name = current_object.name
+            gen.name = current_object.name
+            gen.type = "uml:Generalization"
+
+            # Map definition from ea_connector notes
+            if !ea_connector&.notes.nil? && !ea_connector&.notes&.empty?
+              gen.definition = normalize_line_endings(ea_connector.notes)
+            end
+
+            # Map stereotype from current object
+            gen.stereotype = [current_object.stereotype] unless
+              current_object.stereotype.nil? || current_object.stereotype.empty?
+
+            # Find the package/upper class for the current object
+            if current_object.package_id
+              current_package = find_package(current_object.package_id)
+              if current_package
+                gen.general_upper_klass =
+                  extract_package_prefix(current_package)
+              end
+            end
+
+            # Set has_general flag based on whether parent exists
+            # Use false (not nil) for terminal nodes to match XMI behavior
+            gen.has_general = if ea_connector
+                                !ea_connector.end_object_id.nil?
+                              else
+                                false
+                              end
+
+            # Note: general_attributes, attributes, owned_props, assoc_props,
+            # general, inherited_props, inherited_assoc_props
+            # will be populated in ClassTransformer.load_generalization
+          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
+
+        # Find package by ID
+        # @param package_id [Integer] Package ID
+        # @return [EaPackage, nil] EA package or nil if not found
+        def find_package(package_id)
+          return nil if package_id.nil?
+
+          database.find_package(package_id)
+        end
+
+        # Extract package prefix from package
+        # @param package [EaPackage] EA package
+        # @return [String, nil] Package prefix or nil
+        def extract_package_prefix(package)
+          return nil unless package
+
+          # Try to extract a meaningful prefix from package name
+          # Common patterns: "ModelRoot::i-UR::urf" -> "urf"
+          parts = package.name&.split("::")
+          parts&.last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Transforms EA objects (Object type) to UML instances
+      class InstanceTransformer < BaseTransformer
+        # Transform EA object to UML instance
+        # @param ea_object [EaObject] EA object model
+        # @return [Lutaml::Uml::Instance] UML instance
+        def transform(ea_object) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return nil if ea_object.nil?
+          return nil unless ea_object.instance?
+
+          Lutaml::Uml::Instance.new.tap do |instance|
+            # Map basic properties
+            instance.name = ea_object.name
+            instance.xmi_id = normalize_guid_to_xmi_format(ea_object.ea_guid,
+                                                           "EAID")
+
+            # Map classifier (the class this is an instance of)
+            if ea_object.classifier&.positive?
+              classifier_obj = find_classifier(ea_object.classifier)
+              if classifier_obj
+                instance.classifier = classifier_obj.name
+              end
+            elsif ea_object.classifier_guid && !ea_object.classifier_guid.empty?
+              classifier_obj = find_classifier_by_guid(
+                ea_object.classifier_guid,
+              )
+              if classifier_obj
+                instance.classifier = classifier_obj.name
+              end
+            end
+
+            # Map definition/notes
+            instance.definition = ea_object.note unless
+              ea_object.note.nil? || ea_object.note.empty?
+
+            # Load and transform tagged values
+            instance.tagged_values = load_tagged_values(ea_object.ea_guid)
+          end
+        end
+
+        private
+
+        # Find classifier object by ID
+        # @param classifier_id [Integer] Classifier object ID
+        # @return [EaObject, nil] EA object or nil if not found
+        def find_classifier(classifier_id)
+          return nil if classifier_id.nil? || classifier_id.zero?
+
+          database.find_object(classifier_id)
+        end
+
+        # Find classifier object by GUID
+        # @param classifier_guid [String] Classifier GUID
+        # @return [EaObject, nil] EA object or nil if not found
+        def find_classifier_by_guid(classifier_guid)
+          return nil if classifier_guid.nil? || classifier_guid.empty?
+
+          database.find_object_by_guid(classifier_guid)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Transforms EA ObjectProperty to UML Property/TaggedValue
+      #
+      # This transformer converts Enterprise Architect object properties
+      # (GML/XML Schema encoding metadata) to UML elements. Object properties
+      # are treated as specialized tagged values that enhance UML classes
+      # with schema-specific metadata.
+      #
+      # @example Transform an object property
+      #   ea_prop = Models::EaObjectProperty.new(
+      #     property_id: 1,
+      #     object_id: 684,
+      #     property: "isCollection",
+      #     value: "false"
+      #   )
+      #   transformer = ObjectPropertyTransformer.new
+      #   uml_tag = transformer.transform(ea_prop)
+      class ObjectPropertyTransformer < BaseTransformer
+        # Transform EA object property to UML TaggedValue
+        #
+        # Object properties enhance UML elements with GML/XML encoding
+        # metadata. They are transformed into tagged values to preserve
+        # this semantic information.
+        #
+        # @param ea_property [Models::EaObjectProperty] EA object property
+        # @return [Lutaml::Uml::TaggedValue, nil] UML tagged value or nil
+        def transform(ea_property)
+          return nil unless ea_property
+          return nil unless ea_property.property
+
+          Lutaml::Uml::TaggedValue.new.tap do |tag|
+            tag.name = ea_property.property
+            tag.value = ea_property.value || ""
+            tag.notes = format_notes(ea_property)
+          end
+        end
+
+        private
+
+        # Format notes from EA property
+        #
+        # @param ea_property [Models::EaObjectProperty] EA property
+        # @return [String, nil] Formatted notes
+        def format_notes(ea_property)
+          return nil unless ea_property.notes
+
+          # Clean up EA's note format
+          notes = ea_property.notes.strip
+          notes.empty? ? nil : notes
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Transforms EA operations to UML operations
+      class OperationTransformer < BaseTransformer
+        # Transform EA operation to UML operation
+        # @param ea_operation [EaOperation] EA operation model
+        # @return [Lutaml::Uml::Operation] UML operation
+        def transform(ea_operation) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          return nil if ea_operation.nil?
+
+          Lutaml::Uml::Operation.new.tap do |op|
+            op.name = ea_operation.name
+            op.return_type = ea_operation.type
+            op.visibility = map_visibility(ea_operation.scope)
+            op.xmi_id = ea_operation.ea_guid
+
+            # Build parameter type string from operation parameters
+            op.parameter_type = build_parameter_type(ea_operation)
+
+            # Map definition/notes
+            op.definition = ea_operation.notes unless
+              ea_operation.notes.nil? || ea_operation.notes.empty?
+
+            # Map stereotype if present
+            if ea_operation.stereotype && !ea_operation.stereotype.empty?
+              op.stereotype = [ea_operation.stereotype]
+            end
+          end
+        end
+
+        private
+
+        # Build parameter type string from operation parameters
+        # @param ea_operation [EaOperation] EA operation
+        # @return [String, nil] Parameter type string
+        def build_parameter_type(ea_operation)
+          # Load parameters for this operation
+          params = load_parameters(ea_operation.operationid)
+          return nil if params.empty?
+
+          # Filter out return parameters and build parameter string
+          input_params = params.reject(&:return?)
+          return nil if input_params.empty?
+
+          input_params.map do |param|
+            type_str = param.type || "void"
+            "#{param.name}: #{type_str}"
+          end.join(", ")
+        end
+
+        # Load parameters for an operation
+        # @param operation_id [Integer] Operation ID
+        # @return [Array<EaOperationParam>] Operation parameters
+        def load_parameters(operation_id)
+          return [] if operation_id.nil?
+
+          database.operation_params_for(operation_id)
+            .sort_by { |p| p.pos || 0 }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Transforms EA packages to UML packages
+      class PackageTransformer < BaseTransformer
+        # Transform EA package to UML package
+        # @param ea_package [EaPackage] EA package model
+        # @return [Lutaml::Uml::Package] UML package
+        def transform(ea_package) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          return nil if ea_package.nil?
+
+          Lutaml::Uml::Package.new.tap do |pkg|
+            # Map basic properties
+            pkg.name = ea_package.name
+            pkg.xmi_id = normalize_guid_to_xmi_format(ea_package.ea_guid,
+                                                      "EAPK")
+
+            # Map definition/notes
+            pkg.definition = ea_package.notes unless
+              ea_package.notes.nil? || ea_package.notes.empty?
+
+            # Load and transform tagged values
+            pkg.tagged_values = load_tagged_values(ea_package.ea_guid)
+
+            # Load stereotype from t_xref
+            stereotype = load_stereotype(ea_package.ea_guid)
+            pkg.stereotype = [stereotype] if stereotype
+
+            # Note: Child packages and contents will be loaded separately
+            # to avoid circular dependencies and allow lazy loading
+            # Don't initialize collections - they have default values
+          end
+        end
+
+        # Transform and build complete package hierarchy
+        # @param ea_package [EaPackage] Root EA package
+        # @param include_children [Boolean] Whether to recursively load children
+        # @return [Lutaml::Uml::Package] Complete UML package with hierarchy
+        def transform_with_hierarchy(ea_package, include_children: true)
+          pkg = transform(ea_package)
+          return pkg unless include_children
+
+          # Load child packages
+          child_packages = load_child_packages(ea_package.package_id)
+          pkg.packages = child_packages.map do |child_pkg|
+            transform_with_hierarchy(child_pkg, include_children: true)
+          end
+
+          # Load package contents (classes, diagrams, etc.)
+          load_package_contents(pkg, ea_package.package_id)
+
+          pkg
+        end
+
+        private
+
+        # Load child packages
+        # @param parent_id [Integer] Parent package ID
+        # @return [Array<EaPackage>] Child packages
+        def load_child_packages(parent_id)
+          return [] if parent_id.nil?
+
+          database.child_packages_for(parent_id)
+            .sort_by { |p| p.tpos || 0 }
+        end
+
+        # Load package contents (objects and diagrams)
+        # @param pkg [Lutaml::Uml::Package] UML package to populate
+        # @param package_id [Integer] EA package ID
+        def load_package_contents(pkg, package_id)
+          return if package_id.nil?
+
+          # Load objects (classes, etc.) in this package
+          load_package_objects(pkg, package_id)
+
+          # Load diagrams in this package
+          load_package_diagrams(pkg, package_id)
+        end
+
+        # Maps transformer type keys to UML Package collection methods
+        COLLECTION_FOR_TYPE = {
+          class: :classes,
+          enumeration: :enums,
+          data_type: :data_types,
+          instance: :instances,
+        }.freeze
+
+        # Load objects for a package
+        # @param pkg [Lutaml::Uml::Package] UML package
+        # @param package_id [Integer] Package ID
+        def load_package_objects(pkg, package_id)
+          ea_objects = database.objects_in_package(package_id)
+
+          ea_objects.each do |ea_obj|
+            type_key = ea_obj.transformer_type
+            next unless type_key && COLLECTION_FOR_TYPE.key?(type_key)
+
+            transformer_class = TransformerRegistry.transformer_for(type_key)
+            next unless transformer_class
+
+            uml_element = transformer_class.new(database).transform(ea_obj)
+            next unless uml_element
+
+            collection = COLLECTION_FOR_TYPE[type_key]
+            pkg.public_send(collection) << uml_element
+          end
+        end
+
+        # Load diagrams for a package
+        # @param pkg [Lutaml::Uml::Package] UML package
+        # @param package_id [Integer] Package ID
+        def load_package_diagrams(pkg, package_id)
+          diagram_transformer = DiagramTransformer.new(database)
+
+          ea_diagrams = database.diagrams_in_package(package_id)
+          pkg.diagrams = diagram_transformer.transform_collection(ea_diagrams)
+        end
+
+        # Load stereotype from t_xref table
+        # @param ea_guid [String] Element GUID
+        # @return [String, nil] Stereotype value (as string to match XMI format)
+        def load_stereotype(ea_guid)
+          return nil if ea_guid.nil?
+
+          StereotypeLoader.new(database).load_from_xref(ea_guid)
+        end
+
+        # Check if an object appears on any diagram
+        # @param object_id [Integer] Object ID
+        # @return [Boolean] True if object appears on a diagram
+        def appears_on_diagram?(object_id)
+          return false if object_id.nil?
+          return false unless database.diagram_objects
+
+          # Check if object appears in any diagram's objects
+          database.diagram_objects.any? do |dobj|
+            dobj.ea_object_id == object_id
+          end
+        end
+      end
+    end
+  end
+end