lutaml 0.10.19 → 0.11.2

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

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  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/lutaml/qea/factory/association_transformer.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-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?
-
-          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
-
-        # 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

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

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-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?
-
-          obj = database.find_object(classifier_id.to_i)
-          return nil unless obj
-
-          normalize_guid_to_xmi_format(obj.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

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

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Factory
-      # Abstract base class for all EA to UML transformers
-      # Implements the Strategy pattern for model transformation
-      class BaseTransformer
-        attr_reader :database
-
-        # Initialize transformer with database reference
-        # @param database [Lutaml::Qea::Database] QEA database instance
-        def initialize(database)
-          @database = database
-        end
-
-        # Transform a single EA model to UML model
-        # @param ea_model [BaseModel] EA model instance
-        # @return [Object] UML model instance
-        # @raise [NotImplementedError] Must be implemented by subclasses
-        def transform(ea_model)
-          raise NotImplementedError,
-                "#{self.class} must implement #transform"
-        end
-
-        # Transform a collection of EA models to UML models
-        # @param collection [Array<BaseModel>] Collection of EA models
-        # @return [Array<Object>] Collection of UML models
-        def transform_collection(collection)
-          return [] if collection.nil? || collection.empty?
-
-          collection.filter_map { |item| transform(item) }
-        end
-
-        protected
-
-        # Map EA visibility to UML visibility
-        # @param ea_visibility [String] EA visibility value
-        # @return [String] UML visibility value
-        def map_visibility(ea_visibility) # rubocop:disable Metrics/CyclomaticComplexity
-          return "public" if ea_visibility.nil? || ea_visibility.empty?
-
-          case ea_visibility.downcase
-          when "private" then "private"
-          when "protected" then "protected"
-          when "package" then "package"
-          else "public"
-          end
-        end
-
-        # Parse cardinality string to min/max values
-        # @param cardinality_str [String] Cardinality string (e.g., "0..1",
-        #   "1..*")
-        # @return [Hash] Hash with :min and :max keys
-        def parse_cardinality(cardinality_str)
-          return { min: nil, max: nil } if cardinality_str.nil? ||
-            cardinality_str.empty?
-
-          parts = cardinality_str.split("..")
-          if parts.size == 2
-            { min: parts[0], max: parts[1] }
-          elsif parts.size == 1
-            { min: parts[0], max: parts[0] }
-          else
-            { min: nil, max: nil }
-          end
-        end
-
-        # Convert boolean-like values to actual boolean
-        # @param value [Object] Value to convert
-        # @return [Boolean] Boolean value
-        def to_boolean(value)
-          return false if value.nil?
-          return value if [true, false].include?(value)
-
-          value.to_s == "1" || value.to_s.downcase == "true"
-        end
-
-        # Normalize EA GUID to XMI ID format
-        # Converts {GUID-WITH-HYPHENS} to PREFIX_GUID_WITH_UNDERSCORES
-        # @param ea_guid [String] EA GUID in format
-        # "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
-        # @param prefix [String] Prefix to add (e.g., "EAID", "EAPK")
-        # @return [String, nil] XMI ID in format
-        # "PREFIX_XXXXXXXX_XXXX_XXXX_XXXX_XXXXXXXXXXXX"
-        def normalize_guid_to_xmi_format(ea_guid, prefix = "EAID")
-          return nil if ea_guid.nil? || ea_guid.empty?
-
-          # Remove braces and replace hyphens with underscores
-          clean = ea_guid.tr("{}", "").tr("-", "_")
-          "#{prefix}_#{clean}"
-        end
-
-        # Convert ea_guid to XMI SRC ID format
-        def normalize_guid_to_xmi_src_dst_format(
-          ea_guid, prefix = "EAID", is_src = true # rubocop:disable Style/OptionalBooleanParameter
-        )
-          xmi_id = normalize_guid_to_xmi_format(ea_guid, prefix)
-
-          # Trim prefix and add _src or _dst
-          src_dst = is_src ? "src" : "dst"
-          clean = xmi_id[(prefix.length + 3), xmi_id.length]
-          "#{prefix}_#{src_dst}#{clean}"
-        end
-
-        # Normalize line endings from Windows (\r\n) to Unix (\n)
-        # EA database stores text with Windows line endings, but XMI uses Unix
-        # @param text [String, nil] Text to normalize
-        # @return [String, nil] Text with normalized line endings
-        def normalize_line_endings(text)
-          return nil if text.nil?
-
-          text.gsub("\r\n", "\n")
-        end
-
-        # Find object by ID
-        # @param object_id [Integer] Object ID
-        # @return [Models::EaObject, nil] EA object or nil
-        def find_object_by_id(object_id)
-          return nil if object_id.nil?
-
-          database.find_object(object_id)
-        end
-      end
-    end
-  end
-end