lutaml 0.10.13 → 0.10.15

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

@@ -17,73 +17,111 @@ module Lutaml
       class ClassTransformer < BaseTransformer
         def transform(ea_object)
           return nil if ea_object.nil?
-
-          is_class_type = ea_object.uml_class? || ea_object.interface?
-          is_proxy = ea_object.object_type == "ProxyConnector"
-          is_text_class = ea_object.object_type == "Text"
-          return nil unless is_class_type || is_proxy || is_text_class
+          return nil unless transformable?(ea_object)
 
           Lutaml::Uml::Class.new.tap do |klass|
-            klass.name = ea_object.name
-            klass.xmi_id = normalize_guid_to_xmi_format(ea_object.ea_guid,
-                                                        "EAID")
-            klass.is_abstract = ea_object.abstract?
-            klass.type = "Class"
-            klass.visibility = map_visibility(ea_object.visibility)
-
-            stereotypes = build_stereotypes(ea_object)
-            klass.stereotype = stereotypes unless stereotypes.empty?
-
-            klass.definition = normalize_line_endings(ea_object.note) unless
-              ea_object.note.nil? || ea_object.note.empty?
-
-            gen_builder = GeneralizationBuilder.new(database)
-            assoc_builder = AssociationBuilder.new(database)
-
-            attrs = load_attributes(ea_object.ea_object_id)
-            assoc_attrs = gen_builder.convert_to_top_element_attributes(
-              assoc_builder.load_association_attributes(ea_object.ea_object_id),
-            )
-            klass.attributes = attrs + assoc_attrs
-
-            klass.operations = load_operations(ea_object.ea_object_id)
-            klass.constraints = load_constraints(ea_object.ea_object_id)
-            klass.tagged_values = load_tagged_values(ea_object.ea_guid)
-            klass.tagged_values.concat(
-              load_object_properties(ea_object.ea_object_id),
-            )
-
-            klass.generalization = gen_builder.load_generalization(
-              ea_object.ea_object_id,
-            )
-            klass.association_generalization = gen_builder
-              .load_association_generalizations(ea_object.ea_object_id)
-
-            klass.associations = assoc_builder.load_class_associations(
-              ea_object.ea_object_id, ea_object.ea_guid
-            )
+            assign_basic_properties(klass, ea_object)
+            assign_features(klass, ea_object)
+            assign_relationships(klass, ea_object)
           end
         end
 
         private
 
+        def transformable?(ea_object)
+          ea_object.uml_class? || ea_object.interface? ||
+            ea_object.object_type == "ProxyConnector" ||
+            ea_object.object_type == "Text"
+        end
+
+        def assign_basic_properties(klass, ea_object)
+          klass.name = ea_object.name
+          klass.xmi_id = normalize_guid_to_xmi_format(ea_object.ea_guid, "EAID")
+          klass.is_abstract = ea_object.abstract?
+          klass.type = "Class"
+          klass.visibility = map_visibility(ea_object.visibility)
+          assign_stereotypes(klass, ea_object)
+          assign_definition(klass, ea_object)
+        end
+
+        def assign_stereotypes(klass, ea_object)
+          stereotypes = build_stereotypes(ea_object)
+          klass.stereotype = stereotypes unless stereotypes.empty?
+        end
+
+        def assign_definition(klass, ea_object)
+          return if ea_object.note.nil? || ea_object.note.empty?
+
+          klass.definition = normalize_line_endings(ea_object.note)
+        end
+
+        def assign_features(klass, ea_object)
+          klass.attributes = load_all_attributes(ea_object)
+          assign_feature_collections(klass, ea_object)
+        end
+
+        def assign_feature_collections(klass, ea_object)
+          klass.operations = load_operations(ea_object.ea_object_id)
+          klass.constraints = load_constraints(ea_object.ea_object_id)
+          klass.tagged_values = load_tagged_values(ea_object.ea_guid)
+          klass.tagged_values.concat(
+            load_object_properties(ea_object.ea_object_id),
+          )
+        end
+
+        def assign_relationships(klass, ea_object)
+          gen_builder = GeneralizationBuilder.new(database)
+          assoc_builder = AssociationBuilder.new(database)
+
+          klass.generalization = gen_builder.load_generalization(
+            ea_object.ea_object_id,
+          )
+          klass.association_generalization = gen_builder
+            .load_association_generalizations(ea_object.ea_object_id)
+
+          klass.associations = assoc_builder.load_class_associations(
+            ea_object.ea_object_id, ea_object.ea_guid
+          )
+        end
+
+        def load_all_attributes(ea_object)
+          gen_builder = GeneralizationBuilder.new(database)
+          assoc_builder = AssociationBuilder.new(database)
+
+          attrs = load_attributes(ea_object.ea_object_id)
+          assoc_attrs = gen_builder.convert_to_top_element_attributes(
+            assoc_builder.load_association_attributes(ea_object.ea_object_id),
+          )
+          attrs + assoc_attrs
+        end
+
         def build_stereotypes(ea_object)
           stereotypes = []
-          if ea_object.stereotype && !ea_object.stereotype.empty?
-            stereotypes << ea_object.stereotype
-          end
+          add_direct_stereotype(stereotypes, ea_object)
+          add_xref_stereotype(stereotypes, ea_object)
+          add_interface_stereotype(stereotypes, ea_object)
+
+          stereotypes
+        end
 
+        def add_direct_stereotype(stereotypes, ea_object)
+          return unless ea_object.stereotype && !ea_object.stereotype.empty?
+
+          stereotypes << ea_object.stereotype
+        end
+
+        def add_xref_stereotype(stereotypes, ea_object)
           xref_stereotype = StereotypeLoader.new(database)
             .load_from_xref(ea_object.ea_guid)
-          if xref_stereotype && !stereotypes.include?(xref_stereotype)
-            stereotypes << xref_stereotype
-          end
+          return unless xref_stereotype && !stereotypes.include?(xref_stereotype)
 
-          if ea_object.interface? && !stereotypes.include?("interface")
-            stereotypes << "interface"
-          end
+          stereotypes << xref_stereotype
+        end
 
-          stereotypes
+        def add_interface_stereotype(stereotypes, ea_object)
+          return unless ea_object.interface? && !stereotypes.include?("interface")
+
+          stereotypes << "interface"
         end
 
         def load_attributes(object_id)

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

@@ -183,35 +183,24 @@ module Lutaml
         # Register package and all its descendants in resolver
         # @param package [Lutaml::Uml::Package] Package to register
         # @return [void]
-        def register_package_hierarchy(package) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        def register_package_hierarchy(package)
           return if package.nil?
 
-          # Register the package itself
           register_element(package)
+          register_package_members(package)
 
-          # Register all classes in the package
-          package.classes&.each do |klass|
-            register_element(klass)
-          end
-
-          # Register all enums in the package
-          package.enums&.each do |enum|
-            register_element(enum)
-          end
-
-          # Register all data types in the package
-          package.data_types&.each do |data_type|
-            register_element(data_type)
+          package.packages&.each do |child_package|
+            register_package_hierarchy(child_package)
           end
+        end
 
-          # Register all instances in the package
-          package.instances&.each do |instance|
-            register_element(instance)
-          end
+        MEMBER_COLLECTIONS = %i[classes enums data_types instances].freeze
 
-          # Recursively register child packages
-          package.packages&.each do |child_package|
-            register_package_hierarchy(child_package)
+        def register_package_members(package)
+          MEMBER_COLLECTIONS.each do |collection|
+            package.public_send(collection)&.each do |elem|
+              register_element(elem)
+            end
           end
         end
 

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

@@ -13,53 +13,63 @@ module Lutaml
         # Transform EA object to UML enum
         # @param ea_object [EaObject] EA object model
         # @return [Lutaml::Uml::Enum] UML enum
-        def transform(ea_object) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+        def transform(ea_object)
           return nil if ea_object.nil?
-          return nil unless ea_object.enumeration? ||
-            (ea_object.stereotype && ea_object.stereotype.downcase == "enumeration")
+          return nil unless enum?(ea_object)
 
           Lutaml::Uml::Enum.new.tap do |enum|
-            # Map basic properties
-            enum.name = ea_object.name
-            enum.xmi_id = normalize_guid_to_xmi_format(ea_object.ea_guid,
-                                                       "EAID")
-            enum.visibility = map_visibility(ea_object.visibility)
-
-            # Map stereotype
-            if ea_object.stereotype && !ea_object.stereotype.empty?
-              enum.stereotype = [ea_object.stereotype]
-            end
-
-            # Map definition/notes
-            enum.definition = ea_object.note unless
-              ea_object.note.nil? || ea_object.note.empty?
-
-            # Load enum values (stored as attributes in EA)
-            enum.values = load_enum_values(ea_object.ea_object_id)
-
-            # Load and transform tagged values
-            enum.tagged_values = load_tagged_values(ea_object.ea_guid)
+            assign_enum_basic(enum, ea_object)
+            assign_enum_features(enum, ea_object)
           end
         end
 
+        def assign_enum_basic(enum, ea_object)
+          enum.name = ea_object.name
+          enum.xmi_id = normalize_guid_to_xmi_format(ea_object.ea_guid,
+                                                     "EAID")
+          enum.visibility = map_visibility(ea_object.visibility)
+          enum.stereotype = [ea_object.stereotype] if valid_stereotype?(ea_object)
+          enum.definition = ea_object.note if note_present?(ea_object)
+        end
+
+        def note_present?(ea_object)
+          ea_object.note && !ea_object.note.empty?
+        end
+
+        def assign_enum_features(enum, ea_object)
+          enum.values = load_enum_values(ea_object.ea_object_id)
+          enum.tagged_values = load_tagged_values(ea_object.ea_guid)
+        end
+
         private
 
+        def enum?(ea_object)
+          ea_object.enumeration? ||
+            (ea_object.stereotype && ea_object.stereotype.downcase == "enumeration")
+        end
+
+        def valid_stereotype?(ea_object)
+          ea_object.stereotype && !ea_object.stereotype.empty?
+        end
+
         # Load enum values (literals) from attributes
         # @param object_id [Integer] Object ID
         # @return [Array<Lutaml::Uml::Value>] Enum values
-        def load_enum_values(object_id) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        def load_enum_values(object_id)
           return [] if object_id.nil?
 
           ea_attrs = database.attributes_for_object(object_id)
             .sort_by { |a| a.pos || 0 }
 
-          ea_attrs.filter_map do |ea_attr|
-            Lutaml::Uml::Value.new.tap do |value|
-              value.name = ea_attr.name
-              value.id = normalize_guid_to_xmi_format(ea_attr.ea_guid, "EAID")
-              value.definition = ea_attr.notes unless
-                ea_attr.notes.nil? || ea_attr.notes.empty?
-            end
+          ea_attrs.filter_map { |ea_attr| build_enum_value(ea_attr) }
+        end
+
+        def build_enum_value(ea_attr)
+          Lutaml::Uml::Value.new.tap do |value|
+            value.name = ea_attr.name
+            value.id = normalize_guid_to_xmi_format(ea_attr.ea_guid, "EAID")
+            value.definition = ea_attr.notes unless
+              ea_attr.notes.nil? || ea_attr.notes.empty?
           end
         end
 

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

@@ -9,78 +9,33 @@ module Lutaml
   module Qea
     module Factory
       class GeneralizationBuilder < BaseTransformer
-        def load_generalization(object_id, visited = Set.new, is_leaf = true) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity,Style/OptionalBooleanParameter
+        def load_generalization(object_id, visited = Set.new, is_leaf = true) # rubocop:disable Style/OptionalBooleanParameter
           return nil if object_id.nil?
-
-          if visited.include?(object_id)
-            warn "Circular inheritance detected for object_id #{object_id}, " \
-                 "stopping recursion"
-            return nil
-          end
+          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
 
-          ea_connector = database.connectors_for_object(object_id)
-            .find { |c| c.generalization? && c.start_object_id == object_id }
-
-          gen_transformer = GeneralizationTransformer.new(database)
-          generalization = if ea_connector.nil?
-                             gen_transformer.transform(nil, current_obj)
-                           else
-                             gen_transformer.transform(ea_connector,
-                                                       current_obj)
-                           end
+          generalization = build_generalization(object_id, current_obj)
           return nil unless generalization
 
-          current_attrs = load_attributes(object_id)
-          current_assoc_attrs = AssociationBuilder.new(database)
-            .load_association_attributes(object_id)
-          general_attrs = convert_to_general_attributes(
-            current_attrs + current_assoc_attrs,
-          )
-
-          upper_klass = generalization.general_upper_klass
-          gen_name = generalization.general_name
-          general_attrs.each do |attr|
-            attr.gen_name = gen_name
-            name_ns = case attr.type_ns
-                      when "core", "gml"
-                        upper_klass
-                      else
-                        attr.type_ns
-                      end
-            attr.name_ns = name_ns || upper_klass
-          end
-
-          generalization.general_attributes = general_attrs
-            .sort_by { |a| [a.name.to_s, a.id] }
+          populate_generalization_attrs(generalization, object_id)
+          populate_parent_generalization(generalization,
+                                         ea_connector_for(object_id), visited)
 
-          generalization.attributes = transform_general_attributes(
-            generalization,
-          )
+          collect_inherited_properties(generalization) if is_leaf && generalization.has_general
 
-          generalization.owned_props = generalization.attributes
-            .reject(&:has_association)
-          generalization.assoc_props = generalization.attributes
-            .select(&:has_association)
-
-          parent_object_id = ea_connector&.end_object_id
-          if parent_object_id
-            parent_gen = load_generalization(parent_object_id, visited, false)
-            if parent_gen
-              generalization.general = parent_gen
-              generalization.has_general = true
-            end
-          end
+          generalization
+        end
 
-          if is_leaf && generalization.has_general
-            collect_inherited_properties(generalization)
-          end
+        def circular_inheritance?(object_id, visited)
+          return false unless visited.include?(object_id)
 
-          generalization
+          warn "Circular inheritance detected for object_id #{object_id}, " \
+               "stopping recursion"
+          true
         end
 
         def load_association_generalizations(object_id)
@@ -90,55 +45,155 @@ module Lutaml
             .select { |c| c.generalization? && c.start_object_id == object_id }
 
           gen_connectors.filter_map do |ea_connector|
-            guid = ea_connector.ea_guid
-            parent_object_id = ea_connector.end_object_id
+            build_assoc_generalization(ea_connector)
+          end
+        end
 
-            parent_obj = find_object_by_id(parent_object_id)
-            next unless parent_obj
+        def convert_to_general_attributes(attributes)
+          attributes.map { |attr| to_general_attribute(attr) }
+        end
 
-            Lutaml::Uml::AssociationGeneralization.new.tap do |ag|
-              ag.id = normalize_guid_to_xmi_format(guid, "EAID")
-              ag.type = "uml:Generalization"
-              ag.general = normalize_guid_to_xmi_format(parent_obj.ea_guid,
-                                                        "EAID")
-            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 convert_to_general_attributes(attributes)
-          attributes.map do |attr|
-            Lutaml::Uml::GeneralAttribute.new.tap do |gen_attr|
-              gen_attr.id = attr.id
-              gen_attr.name = attr.name
-              gen_attr.type = attr.type
-              gen_attr.xmi_id = attr.xmi_id
-              gen_attr.is_derived = !!attr.is_derived
-              gen_attr.cardinality = attr.cardinality
-              gen_attr.definition = attr.definition&.strip
-              gen_attr.association = attr.association
-              gen_attr.has_association = !!attr.association
-              gen_attr.type_ns = attr.type_ns
+        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 convert_to_top_element_attributes(attributes)
-          attributes.map do |attr|
-            Lutaml::Uml::TopElementAttribute.new.tap do |top_attr|
-              top_attr.id = attr.id
-              top_attr.name = attr.name
-              top_attr.type = attr.type
-              top_attr.xmi_id = attr.xmi_id
-              top_attr.cardinality = attr.cardinality
-              top_attr.definition = attr.definition&.strip
-              top_attr.association = attr.association
-              top_attr.type_ns = attr.type_ns
-              top_attr.is_derived = !!attr.is_derived
+        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
 
-        private
+        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?
@@ -152,18 +207,10 @@ module Lutaml
         def transform_general_attributes(generalization)
           upper_klass = generalization.general_upper_klass
           gen_name = generalization.general_name
-          gen_attrs = generalization.general_attributes
 
-          gen_attrs.map do |attr|
+          generalization.general_attributes.map do |attr|
             transformed = attr.dup
-            name_ns = case attr.type_ns
-                      when "core", "gml"
-                        upper_klass
-                      else
-                        attr.type_ns
-                      end
-            name_ns = upper_klass if name_ns.nil?
-            transformed.name_ns = name_ns
+            transformed.name_ns = resolve_name_ns(attr.type_ns, upper_klass)
             transformed.gen_name = gen_name
             transformed.name = "" if transformed.name.nil?
             transformed
@@ -177,26 +224,9 @@ module Lutaml
 
           current_gen = generalization.general
           while current_gen
-            [current_gen.general_attributes,
-             current_gen.attributes].each do |attr_list|
-              attr_list&.each do |attr|
-                attr.upper_klass = current_gen.general_upper_klass
-                attr.level = level
-              end
-            end
-
-            current_gen.attributes.reverse_each do |attr|
-              inherited_attr = attr.dup
-              inherited_attr.upper_klass = current_gen.general_upper_klass
-              inherited_attr.gen_name = current_gen.general_name
-              inherited_attr.level = level
-
-              if attr.has_association
-                inherited_assoc_props << inherited_attr
-              else
-                inherited_props << inherited_attr
-              end
-            end
+            tag_ancestor_attributes(current_gen, level)
+            collect_ancestor_attrs(current_gen, level, inherited_props,
+                                   inherited_assoc_props)
 
             level += 1
             current_gen = current_gen.general

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

@@ -12,21 +12,27 @@ module Lutaml
           return nil if ea_guid.nil?
           return nil unless @database.xrefs
 
-          xref = @database.xrefs.find do |x|
+          xref = find_stereotype_xref(ea_guid)
+          return nil unless xref
+
+          extract_stereotype_name(xref.description)
+        end
+
+        private
+
+        def find_stereotype_xref(ea_guid)
+          @database.xrefs.find do |x|
             x.client == ea_guid && x.name == "Stereotypes" &&
               x.type == "element property"
           end
+        end
 
-          return nil unless xref
-
-          description = xref.description
+        def extract_stereotype_name(description)
           return nil if description.nil? || description.empty?
 
           if description =~ /@STEREO;Name=([^;]+);/
-            return Regexp.last_match(1)
+            Regexp.last_match(1)
           end
-
-          nil
         end
       end
     end