lutaml 0.9.41 → 0.9.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f621771edf0e06706b47f6ae904a914c7b70e7e1aa59deb7014b0b11e78ff44
-  data.tar.gz: e73b37317621f4e795637cb720c4e909f7531a92935ae5d199e06559e97092bf
+  metadata.gz: 237ccb049aa43625e1ae6358777dbe0eace1ad3cb1ff787ba5b5f055746d8d96
+  data.tar.gz: 9158115470db6f478a7dd6a30e738ec388d4efa09b33531d3ed8093e93a024fd
 SHA512:
-  metadata.gz: c3742c1252a487c8a8345d24c43667be8125b764c0d035c15700fa66ac3ee938055f5b5a2d2bf83888480cae399b208c6677408d7d55174ba43ff53b16987f17
-  data.tar.gz: 6e92157660f166291385ee44e55c6e37178494e98aad23e19722d486611458da06bc253c16a9bdf3f16a423a38359d9589a8eab85bcc5d89e4ef4a1170806f82
+  metadata.gz: 06a354ff8cf4d011b01b32df444c988a814c26cc6811dabccf394f5d05d1911a8c8e2cf9b31092c297ee9d9c1d2e602e8a5d4551dd8477752772b199a23f1d2c
+  data.tar.gz: 6fd0577fc2898d1ae1c2aba4fa6da813bf090799263645f45d6be0016b12e1ec7ad68a7674ebd5668a62ba128c7045d33338a862f3a4ff435099fdb15a090e74

data/lib/lutaml/converter/xmi_to_uml.rb

@@ -0,0 +1,440 @@
+module Lutaml
+  module Converter
+    module XmiToUml
+      def create_uml_document(xmi_model)
+        ::Lutaml::Uml::Document.new.tap do |doc|
+          doc.name = xmi_model.model.name
+          doc.packages = create_uml_packages(xmi_model.model)
+        end
+      end
+
+      def create_uml_packages(model)
+        return [] if model.packaged_element.nil?
+
+        packages = model.packaged_element.select do |e|
+          e.type?("uml:Package")
+        end
+
+        packages.map do |package|
+          create_uml_package(package)
+        end
+      end
+
+      def create_uml_package(package) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        pkg = ::Lutaml::Uml::Package.new
+        pkg.xmi_id = package.id
+        pkg.name = get_package_name(package)
+        pkg.definition = doc_node_attribute_value(package.id, "documentation")
+        pkg.stereotype = doc_node_attribute_value(package.id, "stereotype")
+
+        pkg.packages = create_uml_packages(package)
+        pkg.classes = create_uml_classes(package)
+        pkg.enums = create_uml_enums(package)
+        pkg.data_types = create_uml_data_types(package)
+        pkg.diagrams = create_uml_diagrams(package.id)
+
+        pkg
+      end
+
+      def create_uml_classes(package)
+        return [] if package.packaged_element.nil?
+
+        klasses = package.packaged_element.select do |e|
+          e.type?("uml:Class") || e.type?("uml:AssociationClass") ||
+            e.type?("uml:Interface")
+        end
+
+        klasses.map do |klass|
+          create_uml_class(klass)
+        end
+      end
+
+      def create_uml_class(klass) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        ::Lutaml::Uml::Class.new.tap do |k| # rubocop:disable Metrics/BlockLength
+          k.xmi_id = klass.id
+          k.name = klass.name
+          k.type = klass.type.split(":").last
+          k.is_abstract = doc_node_attribute_value(klass.id, "isAbstract")
+          k.definition = doc_node_attribute_value(klass.id, "documentation")
+          k.stereotype = doc_node_attribute_value(klass.id, "stereotype")
+
+          k.attributes = create_uml_class_attributes(klass)
+          k.associations = create_uml_associations(klass.id)
+          k.operations = create_uml_operations(klass)
+          k.constraints = create_uml_constraints(klass.id)
+          k.association_generalization = create_uml_assoc_generalizations(klass)
+
+          if klass.type?("uml:Class")
+            k.generalization = create_uml_generalization(klass)
+          end
+        end
+      end
+
+      def create_uml_enums(package) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        return [] if package.packaged_element.nil?
+
+        enums = package.packaged_element.select do |e|
+          e.type?("uml:Enumeration")
+        end
+
+        enums.map do |enum|
+          ::Lutaml::Uml::Enum.new.tap do |en|
+            en.xmi_id = enum.id
+            en.name = enum.name
+            en.values = create_uml_values(enum)
+            en.definition = doc_node_attribute_value(enum.id, "documentation")
+            en.stereotype = doc_node_attribute_value(enum.id, "stereotype")
+          end
+        end
+      end
+
+      def create_uml_data_types(package) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        return [] if package.packaged_element.nil?
+
+        data_types = package.packaged_element.select do |e|
+          e.type?("uml:DataType")
+        end
+
+        data_types.map do |dt|
+          ::Lutaml::Uml::DataType.new.tap do |data_type|
+            data_type.xmi_id = dt.id
+            data_type.name = dt.name
+            data_type.is_abstract = doc_node_attribute_value(
+              dt.id, "isAbstract"
+            )
+            data_type.definition = doc_node_attribute_value(
+              dt.id, "documentation"
+            )
+            data_type.stereotype = doc_node_attribute_value(
+              dt.id, "stereotype"
+            )
+
+            data_type.attributes = create_uml_class_attributes(dt)
+            data_type.operations = create_uml_operations(dt)
+            data_type.associations = create_uml_associations(dt.id)
+            data_type.constraints = create_uml_constraints(dt.id)
+          end
+        end
+      end
+
+      def create_uml_diagrams(node_id) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        return [] if @xmi_root_model.extension&.diagrams&.diagram.nil?
+
+        diagrams = @xmi_root_model.extension.diagrams.diagram.select do |d|
+          d.model.package == node_id
+        end
+
+        diagrams.map do |diagram|
+          ::Lutaml::Uml::Diagram.new.tap do |dia|
+            dia.xmi_id = diagram.id
+            dia.name = diagram&.properties&.name
+            dia.definition = diagram&.properties&.documentation
+
+            package_id = diagram&.model&.package
+            if package_id
+              dia.package_id = package_id
+              dia.package_name = find_packaged_element_by_id(package_id)&.name
+            end
+          end
+        end
+      end
+
+      def create_uml_class_attributes(klass) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+        return [] if klass.owned_attribute.nil?
+
+        owned_attributes = klass.owned_attribute.select do |attr|
+          attr.type?("uml:Property")
+        end
+
+        owned_attributes.map do |oa|
+          create_uml_attribute(oa)
+        end.compact
+      end
+
+      def create_uml_attribute(owned_attr) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        uml_type = owned_attr.uml_type
+        uml_type_idref = uml_type.idref if uml_type
+
+        ::Lutaml::Uml::TopElementAttribute.new.tap do |attr|
+          attr.id = owned_attr.id
+          attr.name = owned_attr.name
+          attr.type = lookup_entity_name(uml_type_idref) || uml_type_idref
+          attr.xmi_id = uml_type_idref
+          attr.is_derived = owned_attr.is_derived
+          attr.cardinality = ::Lutaml::Uml::Cardinality.new.tap do |car|
+            car.min = owned_attr.lower_value&.value
+            car.max = owned_attr.upper_value&.value
+          end
+          attr.definition = lookup_attribute_documentation(owned_attr.id)
+
+          if owned_attr.association
+            attr.association = owned_attr.association
+            attr.definition = loopup_assoc_def(owned_attr.association)
+            attr.type_ns = get_ns_by_xmi_id(attr.xmi_id)
+          end
+        end
+      end
+
+      def create_uml_cardinality(hash)
+        ::Lutaml::Uml::Cardinality.new.tap do |cardinality|
+          cardinality.min = hash[:min]
+          cardinality.max = hash[:max]
+        end
+      end
+
+      def create_uml_attributes(uml_general_obj) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        upper_klass = uml_general_obj.general_upper_klass
+        gen_attrs = uml_general_obj.general_attributes
+        gen_name = uml_general_obj.general_name
+
+        gen_attrs&.each do |i|
+          name_ns = case i.type_ns
+                    when "core", "gml"
+                      upper_klass
+                    else
+                      i.type_ns
+                    end
+          name_ns = upper_klass if name_ns.nil?
+
+          i.name_ns = name_ns
+          i.gen_name = gen_name
+          i.name = "" if i.name.nil?
+        end
+
+        gen_attrs
+      end
+
+      def create_uml_generalization(klass) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        uml_general_obj, next_general_node_id = get_uml_general(klass.id)
+        return uml_general_obj unless next_general_node_id
+
+        if uml_general_obj.general
+          inherited_props = []
+          inherited_assoc_props = []
+          level = 0
+
+          loop_general_item(
+            uml_general_obj.general,
+            level,
+            inherited_props,
+            inherited_assoc_props,
+          )
+          uml_general_obj.inherited_props = inherited_props.reverse
+          uml_general_obj.inherited_assoc_props = inherited_assoc_props.reverse
+        end
+
+        uml_general_obj
+      end
+
+      def get_uml_general(general_id) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        general_node = find_packaged_element_by_id(general_id)
+        return [] unless general_node
+
+        general_node_attrs = get_uml_general_attributes(general_node)
+        general_upper_klass = find_upper_level_packaged_element(general_id)
+        next_general_node_id = get_next_general_node_id(general_node)
+
+        uml_general = ::Lutaml::Uml::Generalization.new.tap do |gen|
+          gen.general_id = general_id
+          gen.general_name = general_node.name
+          gen.general_attributes = general_node_attrs
+          gen.general_upper_klass = general_upper_klass&.name
+          gen.name = general_node.name
+          gen.type = general_node.type
+          gen.definition = lookup_element_prop_documentation(general_id)
+          gen.stereotype = doc_node_attribute_value(general_id, "stereotype")
+
+          if next_general_node_id
+            gen.general = set_uml_generalization(
+              next_general_node_id,
+            )
+            gen.has_general = true
+            gen.general_id = general_node.id
+            gen.general_name = general_node.name
+          end
+        end
+
+        uml_general.attributes = create_uml_attributes(uml_general)
+        uml_general.owned_props = uml_general.attributes.select do |attr|
+          attr.association.nil?
+        end
+        uml_general.assoc_props = uml_general
+          .attributes.select(&:association)
+
+        [uml_general, next_general_node_id]
+      end
+
+      def get_uml_general_attributes(general_node) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        attrs = create_uml_class_attributes(general_node)
+
+        attrs.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
+            gen_attr.association = attr.association
+            gen_attr.has_association = !!attr.association
+            gen_attr.type_ns = attr.type_ns
+          end
+        end
+      end
+
+      def set_uml_generalization(general_id)
+        uml_general_obj, next_general_node_id = get_uml_general(general_id)
+
+        if next_general_node_id
+          uml_general_obj.general = set_uml_generalization(
+            next_general_node_id,
+          )
+          uml_general_obj.has_general = true
+        end
+
+        uml_general_obj
+      end
+
+      def loop_general_item( # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
+        general_item, level, inherited_props, inherited_assoc_props
+      )
+        gen_upper_klass = general_item.general_upper_klass
+        gen_name = general_item.general_name
+
+        # reverse the order to show super class first
+        general_item.attributes.reverse_each do |attr|
+          attr.upper_klass = gen_upper_klass
+          attr.gen_name = gen_name
+          attr.level = level
+
+          if attr.association
+            inherited_assoc_props << attr
+          else
+            inherited_props << attr
+          end
+        end
+
+        if general_item&.has_general && general_item.general
+          level += 1
+          loop_general_item(
+            general_item.general, level, inherited_props, inherited_assoc_props
+          )
+        end
+      end
+
+      def create_uml_assoc_generalizations(klass)
+        return [] if klass.generalization.nil? || klass.generalization.empty?
+
+        klass.generalization.map do |gen|
+          assoc_gen = ::Lutaml::Uml::AssociationGeneralization.new
+          assoc_gen.id = gen.id
+          assoc_gen.type = gen.type
+          assoc_gen.general = gen.general
+        end
+      end
+
+      def create_uml_associations(xmi_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        matched_element = @xmi_root_model.extension.elements.element
+          .find { |e| e.idref == xmi_id }
+
+        return if !matched_element || !matched_element.links
+
+        links = []
+        matched_element.links.each do |link|
+          links << link.association if link.association.any?
+        end
+
+        links.flatten.compact.map do |assoc| # rubocop:disable Metrics/BlockLength
+          link_member = assoc.start == xmi_id ? "end" : "start"
+          link_owner = link_member == "start" ? "end" : "start"
+
+          member_end, member_end_type, member_end_cardinality,
+            member_end_attribute_name, member_end_xmi_id =
+            serialize_member_type(xmi_id, assoc, link_member)
+
+          owner_end = serialize_owned_type(xmi_id, assoc, link_owner)
+          doc_node = link_member == "start" ? "source" : "target"
+          definition = fetch_definition_node_value(assoc.id, doc_node)
+
+          if member_end &&
+              (
+                (member_end_type != "aggregation") ||
+                (member_end_type == "aggregation" && member_end_attribute_name)
+              )
+
+            ::Lutaml::Uml::Association.new.tap do |association|
+              association.xmi_id = assoc.id
+              association.member_end = member_end
+              association.member_end_type = member_end_type
+              association.member_end_cardinality = create_uml_cardinality(
+                member_end_cardinality,
+              )
+              association.member_end_attribute_name = member_end_attribute_name
+              association.member_end_xmi_id = member_end_xmi_id
+              association.owner_end = owner_end
+              association.owner_end_xmi_id = xmi_id
+              association.definition = definition
+            end
+          end
+        end.compact
+      end
+
+      def create_uml_operations(klass) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        return [] if klass.owned_operation.nil?
+
+        klass.owned_operation.map do |operation|
+          uml_type = operation.uml_type.first
+          uml_type_idref = uml_type.idref if uml_type
+
+          if operation.association.nil?
+            ::Lutaml::Uml::Operation.new.tap do |op|
+              op.id = operation.id
+              op.xmi_id = uml_type_idref
+              op.name = operation.name
+              op.definition = lookup_attribute_documentation(operation.id)
+            end
+          end
+        end.compact
+      end
+
+      def create_uml_constraints(klass_id) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        connector_node = fetch_connector(klass_id)
+        return [] if connector_node.nil?
+
+        # In ea-xmi-2.5.1, constraints are moved to source/target under
+        # connectors
+        constraints = %i[source target].map do |st|
+          connector_node.send(st).constraints.constraint
+        end.flatten
+
+        constraints.map do |constraint|
+          ::Lutaml::Uml::Constraint.new.tap do |con|
+            con.name = HTMLEntities.new.decode(constraint.name)
+            con.type = constraint.type
+            con.weight = constraint.weight
+            con.status = constraint.status
+          end
+        end
+      end
+
+      def create_uml_values(enum) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize
+        return [] if enum.owned_literal.nil?
+
+        owned_literals = enum.owned_literal.select do |owned_literal|
+          owned_literal.type?("uml:EnumerationLiteral")
+        end
+
+        owned_literals.map do |owned_literal|
+          uml_type_id = owned_literal&.uml_type&.idref
+
+          ::Lutaml::Uml::Value.new.tap do |value|
+            value.name = owned_literal.name
+            value.type = lookup_entity_name(uml_type_id) || uml_type_id
+            value.definition = lookup_attribute_documentation(owned_literal.id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml/association_generalization.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class AssociationGeneralization < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :type, :string
+      attribute :general, :string
+
+      yaml do
+        map "id", to: :id
+        map "type", to: :type
+        map "general", to: :general
+      end
+    end
+  end
+end

data/lib/lutaml/uml/class.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "lutaml/uml/package"
 require "lutaml/uml/association"
 require "lutaml/uml/constraint"
 require "lutaml/uml/operation"
 require "lutaml/uml/data_type"
+require "lutaml/uml/generalization"
 
 module Lutaml
   module Uml
@@ -13,7 +13,6 @@ module Lutaml
                                              default: -> { [] }
       attribute :is_abstract, :boolean, default: false
       attribute :type, :string
-      attribute :package, Package
       attribute :attributes, TopElementAttribute, collection: true
       attribute :modifier, :string
       attribute :constraints, Constraint, collection: true
@@ -22,12 +21,12 @@ module Lutaml
       attribute :methods, :string, collection: true, default: -> { [] }
 
       attribute :associations, Association, collection: true
+      attribute :generalization, Generalization
 
       yaml do
         map "nested_classifier", to: :nested_classifier
         map "is_abstract", to: :is_abstract
         map "type", to: :type
-        map "package", to: :package
         map "attributes", to: :attributes
         map "modifier", to: :modifier
         map "constraints", to: :constraints

data/lib/lutaml/uml/classifier.rb

@@ -3,10 +3,12 @@
 module Lutaml
   module Uml
     class Classifier < TopElement
-      attribute :generalization, :string, collection: true, default: -> { [] }
+      attribute :association_generalization,
+                ::Lutaml::Uml::AssociationGeneralization,
+                collection: true, default: -> { [] }
 
       yaml do
-        map "generalization", to: :generalization
+        map "generalization", to: :association_generalization
       end
     end
   end

data/lib/lutaml/uml/diagram.rb

@@ -3,6 +3,13 @@
 module Lutaml
   module Uml
     class Diagram < TopElement
+      attribute :package_id, :string
+      attribute :package_name, :string
+
+      yaml do
+        map "package_id", to: :package_id
+        map "package_name", to: :package_name
+      end
     end
   end
 end

data/lib/lutaml/uml/general_attribute.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class GeneralAttribute < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :name, :string
+      attribute :type, :string
+      attribute :xmi_id, :string
+      attribute :is_derived, :boolean, default: false
+      attribute :cardinality, Cardinality
+      attribute :definition, :string
+      attribute :association, :string
+      attribute :has_association, :boolean, default: false
+      attribute :type_ns, :string
+      attribute :name_ns, :string
+      attribute :gen_name, :string
+      attribute :upper_klass, :string
+      attribute :level, :integer
+    end
+  end
+end

data/lib/lutaml/uml/generalization.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class Generalization < Lutaml::Model::Serializable
+      attribute :general_id, :string
+      attribute :general_name, :string
+      attribute :general_attributes,
+                ::Lutaml::Uml::GeneralAttribute,
+                collection: true, default: -> { [] }
+      attribute :general_upper_klass, :string
+      attribute :has_general, :boolean, default: false
+      attribute :general, ::Lutaml::Uml::Generalization
+      attribute :name, :string
+      attribute :type, :string
+      attribute :definition, :string
+      attribute :stereotype, :string
+      attribute :attributes,
+                ::Lutaml::Uml::GeneralAttribute,
+                collection: true, default: -> { [] }
+      attribute :owned_props,
+                ::Lutaml::Uml::GeneralAttribute,
+                collection: true, default: -> { [] }
+      attribute :assoc_props,
+                ::Lutaml::Uml::GeneralAttribute,
+                collection: true, default: -> { [] }
+      attribute :inherited_props,
+                ::Lutaml::Uml::GeneralAttribute,
+                collection: true, default: -> { [] }
+      attribute :inherited_assoc_props,
+                ::Lutaml::Uml::GeneralAttribute,
+                collection: true, default: -> { [] }
+    end
+  end
+end

data/lib/lutaml/uml/top_element_attribute.rb

@@ -15,6 +15,8 @@ module Lutaml
       attribute :is_derived, :boolean, default: false
 
       attribute :definition, :string
+      attribute :association, :string
+      attribute :type_ns, :string
 
       yaml do
         map "name", to: :name
@@ -31,6 +33,8 @@ module Lutaml
         map "definition", to: :definition, with: {
           to: :definition_to_yaml, from: :definition_from_yaml
         }
+        map "association", to: :association
+        map "type_ns", to: :type_ns
       end
 
       def definition_to_yaml(model, doc)

data/lib/lutaml/uml.rb

@@ -10,6 +10,9 @@ require "lutaml/uml/fidelity"
 require "lutaml/uml/top_element"
 require "lutaml/uml/top_element_attribute"
 require "lutaml/uml/value"
+require "lutaml/uml/association_generalization"
+require "lutaml/uml/general_attribute"
+require "lutaml/uml/generalization"
 require "lutaml/uml/action"
 require "lutaml/uml/classifier"
 require "lutaml/uml/dependency"

data/lib/lutaml/version.rb

@@ -1,3 +1,3 @@
 module Lutaml
-  VERSION = "0.9.41".freeze
+  VERSION = "0.9.43".freeze
 end

data/lib/lutaml/xmi/liquid_drops/enum_drop.rb

@@ -41,7 +41,8 @@ module Lutaml
       # @return name of the upper packaged element
       def upper_packaged_element
         if @options[:with_gen]
-          find_upper_level_packaged_element(@model.id)
+          e = find_upper_level_packaged_element(@model.id)
+          e&.name
         end
       end
 

data/lib/lutaml/xmi/liquid_drops/generalization_drop.rb

@@ -38,16 +38,16 @@ module Lutaml
         !!@gen[:general]
       end
 
-      def attributes # rubocop:disable Metrics/MethodLength
+      def attributes # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
         attrs = @gen[:general_attributes]
         attrs.each do |i|
           name_ns = case i[:type_ns]
                     when "core", "gml"
-                      upper_klass
+                      upper_klass&.name
                     else
                       i[:type_ns]
                     end
-          name_ns = upper_klass if name_ns.nil?
+          name_ns = upper_klass&.name if name_ns.nil?
 
           i[:name_ns] = name_ns
           i[:name] = "" if i[:name].nil?

data/lib/lutaml/xmi/liquid_drops/klass_drop.rb

@@ -51,7 +51,17 @@ module Lutaml
       end
 
       def absolute_path
-        "#{@options[:absolute_path]}::#{name}"
+        absolute_path_arr = [@model.name]
+        e = find_upper_level_packaged_element(@model.id)
+        absolute_path_arr << e.name if e
+
+        while e
+          e = find_upper_level_packaged_element(e.id)
+          absolute_path_arr << e.name if e
+        end
+
+        absolute_path_arr << "::#{@xmi_root_model.model.name}"
+        absolute_path_arr.reverse.join("::")
       end
 
       def package
@@ -170,7 +180,7 @@ module Lutaml
 
       def generalization
         if @options[:with_gen] && @model.type?("uml:Class")
-          generalization = serialize_generalization(@model)
+          generalization = serialize_generalization(@model, @options)
           return {} if generalization.nil?
 
           ::Lutaml::XMI::GeneralizationDrop.new(
@@ -181,7 +191,8 @@ module Lutaml
 
       def upper_packaged_element
         if @options[:with_gen]
-          find_upper_level_packaged_element(@model.id)
+          e = find_upper_level_packaged_element(@model.id)
+          e&.name
         end
       end
 

data/lib/lutaml/xmi/liquid_drops/package_drop.rb

@@ -40,7 +40,17 @@ module Lutaml
       end
 
       def absolute_path
-        "#{@options[:absolute_path]}::#{name}"
+        absolute_path_arr = [@model.name]
+        e = find_upper_level_packaged_element(@model.id)
+        absolute_path_arr << e.name if e
+
+        while e
+          e = find_upper_level_packaged_element(e.id)
+          absolute_path_arr << e.name if e
+        end
+
+        absolute_path_arr << "::#{@xmi_root_model.model.name}"
+        absolute_path_arr.reverse.join("::")
       end
 
       def klasses # rubocop:disable Metrics/MethodLength

data/lib/lutaml/xmi/parsers/xmi_base.rb

@@ -135,14 +135,12 @@ module Lutaml
           end
 
           klasses.map do |klass|
-            h = build_klass_hash(
+            build_klass_hash(
               klass, model,
-              with_gen: with_gen
+              with_gen: with_gen,
+              with_absolute_path: with_absolute_path,
+              absolute_path: absolute_path
             )
-
-            h[:absolute_path] = absolute_path if with_absolute_path
-
-            h
           end
         end
 
@@ -151,7 +149,7 @@ module Lutaml
         # @param with_gen: [Boolean]
         # @param with_absolute_path: [Boolean]
         # @return [Hash]
-        def build_klass_hash(klass, model, # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        def build_klass_hash(klass, model, # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity
           with_gen: false, with_absolute_path: false, absolute_path: "")
           klass_hash = {
             xmi_id: klass.id,
@@ -173,17 +171,30 @@ module Lutaml
             klass_hash[:generalization] = serialize_generalization(klass)
           end
 
+          if klass.generalization && !klass.generalization.empty?
+            klass_hash[:association_generalization] = []
+            klass.generalization.each do |gen|
+              klass_hash[:association_generalization] << {
+                id: gen.id,
+                type: gen.type,
+                general: gen.general,
+              }
+            end
+          end
+
           klass_hash
         end
 
         # @param klass [Lutaml::Model::Serializable]
         # # @return [Hash]
-        def serialize_generalization(klass)
-          general_hash, next_general_node_id = get_top_level_general_hash(klass)
+        def serialize_generalization(klass, options = {})
+          general_hash, next_general_node_id = get_top_level_general_hash(
+            klass, options
+          )
           return general_hash unless next_general_node_id
 
           general_hash[:general] = serialize_generalization_attributes(
-            next_general_node_id,
+            next_general_node_id, options
           )
 
           general_hash
@@ -191,59 +202,38 @@ module Lutaml
 
         # @param klass [Lutaml::Model::Serializable]
         # @return [Array<Hash>]
-        def get_top_level_general_hash(klass) # rubocop:disable Metrics/AbcSize
-          general_hash, next_general_node_id = get_general_hash(klass.id)
+        def get_top_level_general_hash(klass, options = {}) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          general_hash, next_general_node_id = get_general_hash(
+            klass.id, options
+          )
           general_hash[:name] = klass.name
           general_hash[:type] = klass.type
-          general_hash[:definition] = lookup_general_documentation(klass.id)
+          general_hash[:definition] =
+            lookup_element_prop_documentation(klass.id)
           general_hash[:stereotype] = doc_node_attribute_value(
             klass.id, "stereotype"
           )
 
-          # update_inherited_attributes(general_hash)
-          # update_gen_attributes(general_hash)
-
           [general_hash, next_general_node_id]
         end
 
-        def lookup_general_documentation(klass_id)
-          # lookup_attribute_documentation(klass_id) ||
-          #   lookup_element_prop_documentation(klass_id)
-
-          lookup_element_prop_documentation(klass_id)
-        end
-
-        def update_gen_attributes(general_hash)
-          general_hash[:gen_attributes] = serialize_gen_attributes
-        end
-
-        def update_inherited_attributes(general_hash)
-          general_hash[:gml_attributes] = serialize_gml_attributes
-          general_hash[:core_attributes] = serialize_core_attributes
-        end
-
         # @param xmi_id [String]
         # @param model [Lutaml::Model::Serializable]
         # @return [Array<Hash>]
         # @note get generalization node and its owned attributes
-        def serialize_generalization_attributes(general_id)
-          general_hash, next_general_node_id = get_general_hash(general_id)
+        def serialize_generalization_attributes(general_id, options = {}) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          general_hash, next_general_node_id = get_general_hash(general_id,
+                                                                options)
 
           if next_general_node_id
             general_hash[:general] = serialize_generalization_attributes(
-              next_general_node_id,
+              next_general_node_id, options
             )
           end
 
           general_hash
         end
 
-        # @param xmi_id [String]
-        # @return [Lutaml::Model::Serializable]
-        def get_general_node(xmi_id)
-          find_packaged_element_by_id(xmi_id)
-        end
-
         # @param general_node [Lutaml::Model::Serializable]
         # @return [Hash]
         def get_general_attributes(general_node)
@@ -258,8 +248,8 @@ module Lutaml
 
         # @param general_id [String]
         # @return [Array<Hash>]
-        def get_general_hash(general_id)
-          general_node = get_general_node(general_id)
+        def get_general_hash(general_id, options = {}) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          general_node = find_packaged_element_by_id(general_id)
           return [] unless general_node
 
           general_node_attrs = get_general_attributes(general_node)
@@ -271,7 +261,8 @@ module Lutaml
               general_id: general_id,
               general_name: general_node.name,
               general_attributes: general_node_attrs,
-              general_upper_klass: general_upper_klass,
+              general_upper_klass: ::Lutaml::XMI::PackageDrop
+                .new(general_upper_klass, nil, options),
               general: {},
             },
             next_general_node_id,
@@ -338,7 +329,7 @@ module Lutaml
 
           all_packaged_elements.each do |e|
             e.packaged_element.each do |pe|
-              @upper_level_cache[pe.id] = e.name
+              @upper_level_cache[pe.id] = e
             end
           end
         end
@@ -435,25 +426,25 @@ module Lutaml
         # @return [Lutaml::Model::Serializable]
         def select_dependencies_by_client(client_id)
           all_packaged_elements.select do |e|
-            e.client == client_id &&
-              e.type?("uml:Dependency")
+            e.client == client_id && e.type?("uml:Dependency")
           end
         end
 
         # @param name [String]
         # @return [Lutaml::Model::Serializable]
         def find_packaged_element_by_name(name)
-          all_packaged_elements.find do |e|
-            e.name == name
-          end
+          all_packaged_elements.find { |e| e.name == name }
         end
 
         # @param package [Lutaml::Model::Serializable]
         # @return [Array<Hash>]
         # @note xpath ./packagedElement[@xmi:type="uml:Enumeration"]
-        def serialize_model_enums(package)
-          package.packaged_element.select { |e| e.type?("uml:Enumeration") }
-            .map do |enum|
+        def serialize_model_enums(package) # rubocop:disable Metrics/MethodLength
+          enums = package.packaged_element.select do |e|
+            e.type?("uml:Enumeration")
+          end
+
+          enums.map do |enum|
             {
               xmi_id: enum.id,
               name: enum.name,
@@ -489,8 +480,9 @@ module Lutaml
         # @note xpath ./packagedElement[@xmi:type="uml:DataType"]
         def serialize_model_data_types(model) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
           all_data_type_elements = []
-          select_all_packaged_elements(all_data_type_elements, model,
-                                       "uml:DataType")
+          select_all_packaged_elements(
+            all_data_type_elements, model, "uml:DataType"
+          )
           all_data_type_elements.map do |klass|
             {
               xmi_id: klass.id,
@@ -828,8 +820,11 @@ module Lutaml
         # @return [Array<Hash>]
         # @note xpath .//ownedAttribute[@xmi:type="uml:Property"]
         def serialize_class_attributes(klass, with_assoc: false) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-          klass.owned_attribute.select { |attr| attr.type?("uml:Property") }
-            .map do |oa|
+          owned_attributes = klass.owned_attribute.select do |attr|
+            attr.type?("uml:Property")
+          end
+
+          owned_attributes.map do |oa|
             if with_assoc || oa.association.nil?
               attrs = build_class_attributes(oa)
 
@@ -849,44 +844,6 @@ module Lutaml
           connector&.documentation&.value
         end
 
-        # @return [Array<Hash>]
-        def serialize_gml_attributes
-          element = find_packaged_element_by_name("_Feature")
-          attrs = serialize_class_attributes(element, with_assoc: true)
-          attrs.each { |attr| attr[:upper_klass] = "gml" }
-        end
-
-        # @return [Array<Hash>]
-        def serialize_core_attributes
-          element = find_packaged_element_by_name("_CityObject")
-          attrs = serialize_class_attributes(element, with_assoc: false)
-          attrs.each { |attr| attr[:upper_klass] = "core" }
-        end
-
-        # @return [Array<Hash>]
-        def select_gen_attributes
-          element = find_packaged_element_by_name("gen")
-          gen_attr_element = find_packaged_element_by_name("_genericAttribute")
-
-          element.packaged_element.select do |e|
-            e.type?("uml:Class") &&
-              e.generalization&.first&.general == gen_attr_element.id
-          end
-        end
-
-        # @return [Array<Hash>]
-        def serialize_gen_attributes
-          klasses = select_gen_attributes
-
-          klasses.map do |klass|
-            attr = serialize_class_attributes(klass, with_assoc: false)
-            attr.first[:name] = klass.name
-            attr.first[:type] = "gen:#{klass.name}"
-            attr.first[:upper_klass] = "gen"
-            attr
-          end.flatten!
-        end
-
         # @param type [String]
         # @return [String]
         def get_ns_by_type(type)
@@ -895,7 +852,7 @@ module Lutaml
           p = find_klass_packaged_element_by_name(type)
           return unless p
 
-          find_upper_level_packaged_element(p.id)
+          find_upper_level_packaged_element(p.id)&.name
         end
 
         # @param xmi_id [String]
@@ -906,7 +863,7 @@ module Lutaml
           p = find_packaged_element_by_id(xmi_id)
           return unless p
 
-          find_upper_level_packaged_element(p.id)
+          find_upper_level_packaged_element(p.id)&.name
         end
 
         # @param klass_id [String]

data/lib/lutaml/xmi/parsers/xml.rb

@@ -4,14 +4,14 @@ require "lutaml/xmi"
 require "xmi"
 require "lutaml/xmi/parsers/xmi_base"
 require "lutaml/uml"
-require "lutaml/converter/xmi_hash_to_uml"
+require "lutaml/converter/xmi_to_uml"
 
 module Lutaml
   module XMI
     module Parsers
       # Class for parsing .xmi schema files into ::Lutaml::Uml::Document
       class XML
-        include Lutaml::Converter::XmiHashToUml
+        include Lutaml::Converter::XmiToUml
 
         @id_name_mapping_static = {}
         @xmi_root_model_cache_static = {}
@@ -99,8 +99,7 @@ module Lutaml
         # @return [Lutaml::Uml::Document]
         def parse(xmi_model)
           set_xmi_model(xmi_model)
-          serialized_hash = serialize_xmi(xmi_model)
-          create_uml_document(serialized_hash)
+          create_uml_document(xmi_model)
         end
 
         # @param xmi_model [Lutaml::Model::Serializable]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml
 version: !ruby/object:Gem::Version
-  version: 0.9.41
+  version: 0.9.43
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-05 00:00:00.000000000 Z
+date: 2025-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: expressir
@@ -217,7 +217,7 @@ files:
 - lib/lutaml.rb
 - lib/lutaml/command_line.rb
 - lib/lutaml/converter/dsl_to_uml.rb
-- lib/lutaml/converter/xmi_hash_to_uml.rb
+- lib/lutaml/converter/xmi_to_uml.rb
 - lib/lutaml/express.rb
 - lib/lutaml/express/parsers/exp.rb
 - lib/lutaml/formatter.rb
@@ -249,6 +249,7 @@ files:
 - lib/lutaml/uml/activity.rb
 - lib/lutaml/uml/actor.rb
 - lib/lutaml/uml/association.rb
+- lib/lutaml/uml/association_generalization.rb
 - lib/lutaml/uml/behavior.rb
 - lib/lutaml/uml/cardinality.rb
 - lib/lutaml/uml/class.rb
@@ -264,6 +265,8 @@ files:
 - lib/lutaml/uml/event.rb
 - lib/lutaml/uml/fidelity.rb
 - lib/lutaml/uml/final_state.rb
+- lib/lutaml/uml/general_attribute.rb
+- lib/lutaml/uml/generalization.rb
 - lib/lutaml/uml/group.rb
 - lib/lutaml/uml/has_attributes.rb
 - lib/lutaml/uml/has_members.rb

data/lib/lutaml/converter/xmi_hash_to_uml.rb

@@ -1,196 +0,0 @@
-module Lutaml
-  module Converter
-    module XmiHashToUml
-      def create_uml_document(hash)
-        ::Lutaml::Uml::Document.new.tap do |doc|
-          doc.name = hash[:name]
-          hash[:packages]&.each do |package_hash|
-            pkg = create_uml_package(package_hash)
-            doc.packages = [] if doc.packages.nil?
-            doc.packages << pkg
-          end
-        end
-      end
-
-      def create_uml_package(hash) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-        package = ::Lutaml::Uml::Package.new
-        package.xmi_id = hash[:xmi_id]
-        package.name = hash[:name]
-        package.definition = hash[:definition]
-        package.stereotype = hash[:stereotype]
-
-        hash[:classes]&.each do |class_hash|
-          class_obj = create_uml_class(class_hash)
-          package.classes = [] if package.classes.nil?
-          package.classes << class_obj
-        end
-        hash[:enums]&.each do |enum_hash|
-          enum_obj = create_uml_enum(enum_hash)
-          package.enums = [] if package.enums.nil?
-          package.enums << enum_obj
-        end
-        hash[:data_types]&.each do |data_type_hash|
-          data_type_obj = create_uml_data_type(data_type_hash)
-          package.data_types = [] if package.data_types.nil?
-          package.data_types << data_type_obj
-        end
-        hash[:diagrams]&.each do |diagram_hash|
-          diagram_obj = create_uml_diagram(diagram_hash)
-          package.diagrams = [] if package.diagrams.nil?
-          package.diagrams << diagram_obj
-        end
-        hash[:packages]&.each do |package_hash|
-          pkg = create_uml_package(package_hash)
-          package.packages = [] if package.packages.nil?
-          package.packages << pkg
-        end
-
-        package
-      end
-
-      def create_uml_class(hash) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-        ::Lutaml::Uml::Class.new.tap do |klass| # rubocop:disable Metrics/BlockLength
-          klass.xmi_id = hash[:xmi_id]
-          klass.name = hash[:name]
-          klass.type = hash[:type]
-          klass.is_abstract = hash[:is_abstract]
-          klass.definition = hash[:definition]
-          klass.stereotype = hash[:stereotype]
-          hash[:attributes]&.each do |attr_hash|
-            attr = create_uml_attribute(attr_hash)
-            klass.attributes = [] if klass.attributes.nil?
-            klass.attributes << attr
-          end
-          hash[:associations]&.each do |assoc_hash|
-            assoc = create_uml_association(assoc_hash)
-            klass.associations = [] if klass.associations.nil?
-            klass.associations << assoc
-          end
-          hash[:operations]&.each do |op_hash|
-            op = create_uml_operation(op_hash)
-            klass.operations = [] if klass.operations.nil?
-            klass.operations << op
-          end
-          hash[:constraints]&.each do |constraint_hash|
-            constraint = create_uml_constraint(constraint_hash)
-            klass.constraints = [] if klass.constraints
-            klass.constraints << constraint
-          end
-        end
-      end
-
-      def create_uml_enum(hash) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        ::Lutaml::Uml::Enum.new.tap do |enum|
-          enum.xmi_id = hash[:xmi_id]
-          enum.name = hash[:name]
-          hash[:values]&.each do |value_hash|
-            value = create_uml_value(value_hash)
-            enum.values = [] if enum.values.nil?
-            enum.values << value
-          end
-          enum.definition = hash[:definition]
-          enum.stereotype = hash[:stereotype]
-        end
-      end
-
-      def create_uml_data_type(hash) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        ::Lutaml::Uml::DataType.new.tap do |data_type|
-          data_type.xmi_id = hash[:xmi_id]
-          data_type.name = hash[:name]
-          data_type.is_abstract = hash[:is_abstract]
-          data_type.definition = hash[:definition]
-          data_type.stereotype = hash[:stereotype]
-          hash[:attributes]&.each do |attr_hash|
-            attr = create_uml_attribute(attr_hash)
-            data_type.attributes = [] if data_type.attributes.nil?
-            data_type.attributes << attr
-          end
-          hash[:operations]&.each do |op_hash|
-            op = create_uml_operation(op_hash)
-            data_type.operations = [] if data_type.operations.nil?
-            data_type.operations << op
-          end
-          hash[:associations]&.each do |assoc_hash|
-            assoc = create_uml_association(assoc_hash)
-            data_type.associations = [] if data_type.associations.nil?
-            data_type.associations << assoc
-          end
-          hash[:constraints]&.each do |constraint_hash|
-            constraint = create_uml_constraint(constraint_hash)
-            data_type.constraints = [] if data_type.constraints
-            data_type.constraints << constraint
-          end
-        end
-      end
-
-      def create_uml_diagram(hash)
-        ::Lutaml::Uml::Diagram.new.tap do |diagram|
-          diagram.xmi_id = hash[:xmi_id]
-          diagram.name = hash[:name]
-          diagram.definition = hash[:definition]
-        end
-      end
-
-      def create_uml_attribute(hash) # rubocop:disable Metrics/AbcSize
-        ::Lutaml::Uml::TopElementAttribute.new.tap do |attr|
-          attr.id = hash[:id]
-          attr.name = hash[:name]
-          attr.type = hash[:type]
-          attr.xmi_id = hash[:xmi_id]
-          attr.is_derived = hash[:is_derived]
-          attr.cardinality = create_uml_cardinality(hash[:cardinality])
-          attr.definition = hash[:definition]
-        end
-      end
-
-      def create_uml_cardinality(hash)
-        ::Lutaml::Uml::Cardinality.new.tap do |cardinality|
-          cardinality.min = hash[:min]
-          cardinality.max = hash[:max]
-        end
-      end
-
-      def create_uml_association(hash) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        ::Lutaml::Uml::Association.new.tap do |assoc|
-          assoc.xmi_id = hash[:xmi_id]
-          assoc.member_end = hash[:member_end]
-          assoc.member_end_type = hash[:member_end_type]
-          assoc.member_end_cardinality = create_uml_cardinality(
-            hash[:member_end_cardinality],
-          )
-          assoc.member_end_attribute_name = hash[:member_end_attribute_name]
-          assoc.member_end_xmi_id = hash[:member_end_xmi_id]
-          assoc.owner_end = hash[:owner_end]
-          assoc.owner_end_xmi_id = hash[:owner_end_xmi_id]
-          assoc.definition = hash[:definition]
-        end
-      end
-
-      def create_uml_operation(hash)
-        ::Lutaml::Uml::Operation.new.tap do |op|
-          op.id = hash[:id]
-          op.xmi_id = hash[:xmi_id]
-          op.name = hash[:name]
-          op.definition = hash[:definition]
-        end
-      end
-
-      def create_uml_constraint(hash)
-        ::Lutaml::Uml::Constraint.new.tap do |constraint|
-          constraint.name = hash[:name]
-          constraint.type = hash[:type]
-          constraint.weight = hash[:weight]
-          constraint.status = hash[:status]
-        end
-      end
-
-      def create_uml_value(hash)
-        ::Lutaml::Uml::Value.new.tap do |value|
-          value.name = hash[:name]
-          value.type = hash[:type]
-          value.definition = hash[:definition]
-        end
-      end
-    end
-  end
-end