lutaml 0.10.4 → 0.10.6

data/lib/lutaml/cli/uml/build_command.rb

@@ -69,8 +69,8 @@ module Lutaml
                                             desc: "Load metadata from YAML file"
 
           # Build options
-          thor_class.option :format, type: :string, default: "marshal",
-                                     desc: "Serialization format (marshal|yaml)"
+          thor_class.option :format, type: :string, default: "yaml",
+                                     desc: "Serialization format (yaml)"
           thor_class.option :validate, type: :boolean, default: true,
                                        desc: "Validate before building"
           thor_class.option :strict, type: :boolean, default: false,
@@ -166,7 +166,7 @@ module Lutaml
           # Export to package with metadata
           export_options = {
             serialization_format: (
-              options[:format] || options["format"] || "marshal"
+              options[:format] || options["format"] || "yaml"
             ).to_sym,
             metadata: metadata,
           }
@@ -213,7 +213,7 @@ module Lutaml
             name: options[:name] || File.basename(options[:output] || "model",
                                                   ".lur"),
             version: options[:version] || "1.0",
-            serialization_format: (options[:format] || "marshal").to_s,
+            serialization_format: (options[:format] || "yaml").to_s,
           }
 
           # Add optional fields if provided
@@ -273,7 +273,7 @@ module Lutaml
 
           # Ensure serialization_format is set
           metadata_hash["serialization_format"] ||= (
-            options[:format] || "marshal"
+            options[:format] || "yaml"
           ).to_s
 
           Lutaml::UmlRepository::PackageMetadata.from_hash(metadata_hash)

data/lib/lutaml/cli/uml/verify_command.rb

@@ -92,7 +92,6 @@ module Lutaml
           report_data = result.to_report
           ext = File.extname(report_path).downcase
           report_format = case ext
-                          when ".json" then :json
                           when ".yaml", ".yml" then :yaml
                           else :json
                           end

data/lib/lutaml/converter/xmi_to_uml.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "xmi_to_uml_generalization"
+
 module Lutaml
   module Converter
     module XmiToUml
@@ -199,159 +201,6 @@ module Lutaml
         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_st = doc_node_attribute_value(general_id, "stereotype")
-          gen.stereotype = [gen_st] if gen_st
-
-          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.sort_by { |a| [a.name.to_s, a.id] }.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
-          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) # rubocop:disable Metrics/AbcSize
-        return [] if klass.generalization.nil? || klass.generalization.empty?
-
-        klass.generalization.map do |gen|
-          ::Lutaml::Uml::AssociationGeneralization.new.tap do |assoc_gen|
-            assoc_gen.id = gen.id
-            assoc_gen.type = gen.type
-            assoc_gen.general = gen.general
-          end
-        end
-      end
-
       def create_uml_associations(xmi_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
         matched_element = xmi_index&.find_element(xmi_id)
 
@@ -424,6 +273,7 @@ module Lutaml
 
           if !operation.respond_to?(:association) || 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)

data/lib/lutaml/converter/xmi_to_uml_generalization.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Converter
+    module XmiToUml
+      # Generalization-related conversion methods for XMI → UML
+      #
+      # These methods handle the recursive generalization hierarchy:
+      # creating UML generalization objects, walking the chain of
+      # parent classes, and collecting inherited properties.
+
+      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_next_general_node_id(general_node)
+        general_node.generalization.first&.general
+      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 = build_uml_general_node(
+          general_id, general_node, general_node_attrs,
+          general_upper_klass, next_general_node_id
+        )
+
+        assign_general_properties(uml_general)
+
+        [uml_general, next_general_node_id]
+      end
+
+      def build_uml_general_node(general_id, general_node, attrs, upper_klass,
+next_id)
+        gen = ::Lutaml::Uml::Generalization.new
+        assign_general_basic_props(gen, general_id, general_node, attrs,
+                                   upper_klass)
+        assign_stereotype(gen, general_id)
+        assign_parent_generalization(gen, general_node, next_id)
+        gen
+      end
+
+      def assign_general_basic_props(gen, general_id, general_node, attrs,
+upper_klass)
+        gen.general_id = general_id
+        gen.general_name = general_node.name
+        gen.general_attributes = attrs
+        gen.general_upper_klass = upper_klass ? get_package_name(upper_klass) : nil
+        gen.name = general_node.name
+        gen.type = general_node.type
+        gen.definition = lookup_element_prop_documentation(general_id)
+      end
+
+      def assign_stereotype(gen, general_id)
+        gen_st = doc_node_attribute_value(general_id, "stereotype")
+        gen.stereotype = [gen_st] if gen_st
+      end
+
+      def assign_parent_generalization(gen, general_node, next_id)
+        return unless next_id
+
+        gen.general = set_uml_generalization(next_id)
+        gen.has_general = true
+        gen.general_id = general_node.id
+        gen.general_name = general_node.name
+      end
+
+      def assign_general_properties(uml_general)
+        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)
+      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&.strip
+            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) # rubocop:disable Metrics/AbcSize
+        return [] if klass.generalization.nil? || klass.generalization.empty?
+
+        klass.generalization.map do |gen|
+          ::Lutaml::Uml::AssociationGeneralization.new.tap do |assoc_gen|
+            assoc_gen.id = gen.id
+            assoc_gen.type = gen.type
+            assoc_gen.general = gen.general
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/formatter/graphviz.rb

@@ -53,8 +53,7 @@ module Lutaml
         @graph["ranksep"] = "1.2.equally"
         # Padding between nodes
         @graph["nodesep"] = "1.2.equally"
-        # TODO: set rankdir
-        # @graph['rankdir'] = 'BT'
+        @graph["rankdir"] = "BT"
 
         @edge = Attributes.new
         @edge["color"] = "gray50"

data/lib/lutaml/qea/database.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "repositories/object_repository"
+require_relative "lookup_indexes"
 
 module Lutaml
   module Qea
@@ -425,53 +426,6 @@ module Lutaml
         @collections.freeze
         super
       end
-
-      private
-
-      # Build a group index from a collection by a given attribute.
-      # BaseRepository overrides group_by to take a symbol (not a block),
-      # so we use each_with_object instead.
-      #
-      # @param collection [Array] Collection to index
-      # @param method [Symbol] Attribute method to group by
-      # @param single [Boolean] If true, return single object (last match)
-      #   instead of array
-      # @return [Hash] Group index
-      def build_group_index(collection, method, single: false)
-        if single
-          collection.each_with_object({}) do |item, hash|
-            key = item.send(method)
-            hash[key] = item if key
-          end
-        else
-          collection.each_with_object({}) do |item, hash|
-            key = item.send(method)
-            (hash[key] ||= []) << item if key
-          end
-        end
-      end
-
-      # Eagerly build all lazy lookup indexes before freezing
-      def build_lookup_indexes
-        @objects_by_guid = build_group_index(objects, :ea_guid, single: true)
-        @attributes_by_object_id = build_group_index(attributes, :ea_object_id)
-        @operations_by_object_id = build_group_index(operations, :ea_object_id)
-        @operation_params_by_id = build_group_index(operation_params,
-                                                    :operationid)
-        @connectors_by_start = build_group_index(connectors, :start_object_id)
-        @connectors_by_end = build_group_index(connectors, :end_object_id)
-        @packages_by_parent = build_group_index(packages, :parent_id)
-        @objects_by_package_id = build_group_index(objects, :package_id)
-        @diagrams_by_package_id = build_group_index(diagrams, :package_id)
-        @diagram_objects_by_id = build_group_index(diagram_objects, :diagram_id)
-        @diagram_links_by_id = build_group_index(diagram_links, :diagramid)
-        # Also build hash indexes for find_* methods
-        @packages_by_id = build_group_index(packages, :package_id, single: true)
-        @connectors_by_id = build_group_index(connectors, :connector_id,
-                                              single: true)
-        @diagrams_by_id = build_group_index(diagrams, :diagram_id, single: true)
-        @attributes_by_id = build_group_index(attributes, :id, single: true)
-      end
     end
   end
 end

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

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative "base_transformer"
+
+module Lutaml
+  module Qea
+    module Factory
+      class AssociationBuilder < BaseTransformer
+        ASSOC_TYPES = ["Association", "Aggregation", "Composition"].freeze
+
+        def load_class_associations(object_id, object_guid)
+          return [] if object_id.nil?
+
+          associations = []
+          normalized_owner_xmi_id = normalize_guid_to_xmi_format(object_guid,
+                                                                 "EAID")
+
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| ASSOC_TYPES.include?(c.connector_type) }
+
+          assoc_connectors.each do |ea_connector|
+            is_start = ea_connector.start_object_id == object_id
+
+            owner_end_attribute_name = if is_start
+                                         ea_connector.destrole
+                                       else
+                                         ea_connector.sourcerole
+                                       end
+
+            if owner_end_attribute_name.nil? || owner_end_attribute_name.empty?
+              next
+            end
+
+            member_obj = if is_start
+                           find_object_by_id(ea_connector.end_object_id)
+                         else
+                           find_object_by_id(ea_connector.start_object_id)
+                         end
+            next unless member_obj
+
+            member_end_attribute_name = if is_start
+                                          ea_connector.sourcerole
+                                        else
+                                          ea_connector.destrole
+                                        end
+            if member_end_attribute_name.nil? ||
+                member_end_attribute_name.empty?
+              member_end_attribute_name = member_obj.name
+            end
+
+            member_cardinality_str = if is_start
+                                       ea_connector.destcard
+                                     else
+                                       ea_connector.sourcecard
+                                     end
+
+            associations << Lutaml::Uml::Association.new.tap do |assoc|
+              assoc.xmi_id = normalize_guid_to_xmi_format(ea_connector.ea_guid,
+                                                          "EAID")
+              assoc.name = ea_connector.name unless ea_connector.name.nil? || ea_connector.name.empty?
+
+              assoc.owner_end = find_object_by_id(object_id)&.name
+              assoc.owner_end_xmi_id = normalized_owner_xmi_id
+              assoc.owner_end_attribute_name = owner_end_attribute_name
+
+              assoc.member_end = member_obj.name
+              assoc.member_end_xmi_id = normalize_guid_to_xmi_format(
+                member_obj.ea_guid, "EAID"
+              )
+              assoc.member_end_attribute_name = member_end_attribute_name
+
+              assoc.member_end_type = ea_connector.connector_type&.downcase
+
+              if member_cardinality_str && !member_cardinality_str.empty?
+                parsed = parse_cardinality(member_cardinality_str)
+                if parsed[:min] || parsed[:max]
+                  assoc.member_end_cardinality = Lutaml::Uml::Cardinality.new
+                    .tap do |card|
+                      card.min = parsed[:min]
+                      card.max = parsed[:max]
+                    end
+                end
+              end
+            end
+          end
+
+          associations.compact
+        end
+
+        def load_association_attributes(object_id)
+          return [] if object_id.nil?
+
+          attributes = []
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| ASSOC_TYPES.include?(c.connector_type) }
+          obj = find_object_by_id(object_id)
+          obj_pkg_name = find_package_name(obj&.package_id)
+
+          assoc_connectors.each do |ea_connector|
+            if ea_connector.start_object_id == object_id
+              next if ea_connector.destrole.nil? || ea_connector.destrole.empty?
+
+              target_obj = find_object_by_id(ea_connector.end_object_id)
+              next unless target_obj
+
+              target_obj_pkg_name = find_package_name(target_obj.package_id)
+
+              attributes << create_association_attribute(
+                name: ea_connector.destrole,
+                type: target_obj.name,
+                type_xmi_id: target_obj.ea_guid,
+                association_xmi_id: ea_connector.ea_guid,
+                cardinality: ea_connector.destcard,
+                definition: ea_connector.notes,
+                gen_name: obj.name,
+                name_ns: obj_pkg_name,
+                type_ns: target_obj_pkg_name,
+                is_src: false,
+              )
+            elsif ea_connector.end_object_id == object_id
+              next if ea_connector.sourcerole.nil? || ea_connector.sourcerole.empty?
+
+              source_obj = find_object_by_id(ea_connector.start_object_id)
+              next unless source_obj
+
+              source_obj_pkg_name = find_package_name(source_obj.package_id)
+
+              attributes << create_association_attribute(
+                name: ea_connector.sourcerole,
+                type: source_obj.name,
+                type_xmi_id: source_obj.ea_guid,
+                association_xmi_id: ea_connector.ea_guid,
+                cardinality: ea_connector.sourcecard,
+                definition: ea_connector.notes,
+                gen_name: obj.name,
+                name_ns: obj_pkg_name,
+                type_ns: source_obj_pkg_name,
+              )
+            end
+          end
+
+          attributes.compact
+        end
+
+        def create_association_attribute( # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/ParameterLists
+          name:, type:, type_xmi_id:,
+          association_xmi_id:, cardinality:, definition:,
+          gen_name:, name_ns:, type_ns:, is_src: true
+        )
+          Lutaml::Uml::GeneralAttribute.new.tap do |attr|
+            attr.name = name
+            attr.type = type
+            attr.gen_name = gen_name
+            attr.definition = definition
+            attr.xmi_id = normalize_guid_to_xmi_format(type_xmi_id, "EAID")
+            attr.association = normalize_guid_to_xmi_format(
+              association_xmi_id, "EAID"
+            )
+            attr.has_association = true
+            attr.id = normalize_guid_to_xmi_src_dst_format(
+              association_xmi_id, "EAID", is_src
+            )
+            attr.name_ns = name_ns
+            attr.type_ns = type_ns
+
+            if cardinality && !cardinality.empty?
+              parsed = parse_cardinality(cardinality)
+              if parsed[:min] || parsed[:max]
+                attr.cardinality = Lutaml::Uml::Cardinality.new.tap do |card|
+                  card.min = parsed[:min]
+                  card.max = parsed[:max]
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def find_package_name(package_id)
+          return nil if package_id.nil?
+
+          database.find_package(package_id)&.name
+        end
+      end
+    end
+  end
+end

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

@@ -41,7 +41,6 @@ module Lutaml
           return "public" if ea_visibility.nil? || ea_visibility.empty?
 
           case ea_visibility.downcase
-          when "public" then "public"
           when "private" then "private"
           when "protected" then "protected"
           when "package" then "package"