lutaml 0.10.19 → 0.11.2

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

@@ -1,236 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  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 load_attributes(object_id)
-          return [] if object_id.nil?
-
-          ea_attributes = database.attributes_for_object(object_id)
-            .sort_by { |a| a.pos || 0 }
-
-          AttributeTransformer.new(database).transform_collection(ea_attributes)
-        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/lutaml/qea/factory/generalization_transformer.rb

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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  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
-
-        # Load and transform tagged values for an instance
-        # @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/object_property_transformer.rb

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

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