lutaml 0.10.4 → 0.10.6

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

@@ -25,9 +25,6 @@ module Lutaml
             diagram.name = ea_diagram.name
             diagram.xmi_id = normalize_guid_to_xmi_format(ea_diagram.ea_guid,
                                                           "EAID")
-            # TODO: Fix diagram_type assignment -
-            # lutaml-model compatibility issue
-            # diagram.diagram_type = ea_diagram.diagram_type
 
             # Map package relationship - use GUID not numeric ID
             if ea_diagram.package_id

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require_relative "base_transformer"
+require_relative "attribute_transformer"
+require_relative "generalization_transformer"
+require_relative "association_builder"
+
+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
+          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
+
+          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
+          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] }
+
+          generalization.attributes = transform_general_attributes(
+            generalization,
+          )
+
+          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
+
+          if is_leaf && generalization.has_general
+            collect_inherited_properties(generalization)
+          end
+
+          generalization
+        end
+
+        def load_association_generalizations(object_id)
+          return [] if object_id.nil?
+
+          gen_connectors = database.connectors_for_object(object_id)
+            .select { |c| c.generalization? && c.start_object_id == object_id }
+
+          gen_connectors.filter_map do |ea_connector|
+            guid = ea_connector.ea_guid
+            parent_object_id = ea_connector.end_object_id
+
+            parent_obj = find_object_by_id(parent_object_id)
+            next unless parent_obj
+
+            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
+          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
+            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
+            end
+          end
+        end
+
+        private
+
+        def load_attributes(object_id)
+          return [] if object_id.nil?
+
+          ea_attributes = database.attributes_for_object(object_id)
+            .sort_by { |a| a.pos || 0 }
+
+          AttributeTransformer.new(database).transform_collection(ea_attributes)
+        end
+
+        def transform_general_attributes(generalization)
+          upper_klass = generalization.general_upper_klass
+          gen_name = generalization.general_name
+          gen_attrs = generalization.general_attributes
+
+          gen_attrs.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.gen_name = gen_name
+            transformed.name = "" if transformed.name.nil?
+            transformed
+          end
+        end
+
+        def collect_inherited_properties(generalization)
+          inherited_props = []
+          inherited_assoc_props = []
+          level = 0
+
+          current_gen = generalization.general
+          while current_gen
+            [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
+
+            level += 1
+            current_gen = current_gen.general
+          end
+
+          generalization.inherited_props = inherited_props.reverse
+          generalization.inherited_assoc_props = inherited_assoc_props.reverse
+        end
+      end
+    end
+  end
+end

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

@@ -29,8 +29,7 @@ module Lutaml
               ea_package.notes.nil? || ea_package.notes.empty?
 
             # Load and transform tagged values
-            # TODO: Fix tagged_values assignment - temporarily commented out
-            # pkg.tagged_values = load_tagged_values(ea_package.ea_guid)
+            pkg.tagged_values = load_tagged_values(ea_package.ea_guid)
 
             # Load stereotype from t_xref
             stereotype = load_stereotype(ea_package.ea_guid)

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Qea
+    module Factory
+      class StereotypeLoader
+        def initialize(database)
+          @database = database
+        end
+
+        def load_from_xref(ea_guid)
+          return nil if ea_guid.nil?
+          return nil unless @database.xrefs
+
+          xref = @database.xrefs.find do |x|
+            x.client == ea_guid && x.name == "Stereotypes" &&
+              x.type == "element property"
+          end
+
+          return nil unless xref
+
+          description = xref.description
+          return nil if description.nil? || description.empty?
+
+          if description =~ /@STEREO;Name=([^;]+);/
+            return Regexp.last_match(1)
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/lookup_indexes.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Qea
+    class Database
+      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/models/ea_datatype.rb

@@ -80,8 +80,6 @@ module Lutaml
         # @return [String]
         def type_signature
           case size
-          when 0
-            datatype
           when 1
             "#{datatype}(#{defaultlen})"
           when 2

data/lib/lutaml/qea/validation/validation_engine.rb

@@ -433,8 +433,6 @@ module Lutaml
         # @return [void]
         def display_result(result, formatter)
           case formatter
-          when :text
-            display_text_result(result)
           when :json
             puts result.to_json
           else

data/lib/lutaml/uml/has_members.rb

@@ -5,7 +5,6 @@ module Lutaml
     module HasMembers
       class UnknownMemberTypeError < Lutaml::Error; end
 
-      # TODO: move to Parslet::Transform
       def members=(value) # rubocop:disable Metrics/AbcSize
         value.group_by { |member| member.keys.first }
           .each do |(type, group)|

data/lib/lutaml/uml/inheritance_walker.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    # Service class for safely walking UML generalization chains.
+    #
+    # Walks from a class up through its generalization hierarchy (parent classes),
+    # collecting information about each ancestor. Supports cycle detection to
+    # prevent infinite loops in malformed models.
+    #
+    # @example
+    #   walker = InheritanceWalker.new(repository)
+    #   walker.walk(klass) do |ancestor, level|
+    #     puts "#{'-' * level} #{ancestor.name}"
+    #   end
+    class InheritanceWalker
+      # @param repository [#supertype_of] Object responding to #supertype_of(class)
+      def initialize(repository)
+        @repository = repository
+        @visited = Set.new
+      end
+
+      # Walk the generalization chain from a starting class.
+      #
+      # @param klass [Lutaml::Uml::Class] The class to start from
+      # @yield [ancestor, level] Yields each ancestor class and its depth (1-based)
+      # @return [Array<[klass, level]>] Array of [ancestor_class, level] pairs in visiting order
+      #
+      # @example
+      #   walker.walk(D.class) do |parent, level|
+      #     puts "#{'  ' * (level - 1)}Parent #{level}: #{parent.name}"
+      #   end
+      def walk(klass)
+        return [] unless klass.respond_to?(:generalization) && klass.generalization
+
+        ancestors = []
+        @visited.clear
+        collect_ancestors(klass, ancestors)
+        ancestors.reverse_each.with_index(1) do |ancestor, level|
+          break if @visited.include?(ancestor.xmi_id)
+
+          @visited.add(ancestor.xmi_id)
+          yield(ancestor, level) if block_given?
+        end
+        ancestors.reverse_each.with_index(1)
+      end
+
+      # Get the direct supertype (immediate parent) of a class.
+      #
+      # @param klass [Lutaml::Uml::Class]
+      # @return [Lutaml::Uml::Class, nil]
+      def supertype_of(klass)
+        @repository.supertype_of(klass)
+      end
+
+      # Get all ancestors of a class in order (immediate parent first).
+      #
+      # @param klass [Lutaml::Uml::Class]
+      # @return [Array<Lutaml::Uml::Class>]
+      def ancestors_of(klass)
+        result = []
+        walk(klass) { |ancestor, _level| result << ancestor }
+        result
+      end
+
+      private
+
+      # Collect ancestors recursively into the result array.
+      # Uses a trail set for cycle detection (avoids Set mutation issues across calls).
+      def collect_ancestors(klass, result, trail = [])
+        return [] if trail.include?(klass.xmi_id) # cycle guard
+        return [] unless klass.respond_to?(:generalization) && klass.generalization
+
+        trail = trail.dup
+        trail << klass.xmi_id
+
+        general_id = klass.generalization.respond_to?(:general_id) ? klass.generalization.general_id : nil
+        parent = general_id ? find_class_by_id(general_id) : nil
+
+        return [] unless parent
+
+        result << parent
+        collect_ancestors(parent, result, trail)
+      end
+
+      def find_class_by_id(xmi_id)
+        @repository.indexes&.dig(:qualified_names, xmi_id) ||
+          @repository.send(:classes_index)&.find { |c| c.xmi_id == xmi_id }
+      end
+    end
+  end
+end

data/lib/lutaml/uml/model_helpers.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    # Shared helper methods for UML model objects.
+    # These methods are used across transformers, serializers, and presenters
+    # to avoid duplication of common model traversal and formatting logic.
+    module ModelHelpers
+      # Normalize a stereotype value to a consistent Array format.
+      #
+      # @param stereotype [String, Array, nil, Symbol] The stereotype value
+      # @return [Array<String>] Array of stereotype strings
+      #
+      # @example
+      #   normalize_stereotypes(nil)                    # => []
+      #   normalize_stereotypes("enumeration")        # => ["enumeration"]
+      #   normalize_stereotypes(["a", "b"])           # => ["a", "b"]
+      #   normalize_stereotypes(:enumeration)         # => ["enumeration"]
+      def normalize_stereotypes(stereotype)
+        return [] if stereotype.nil?
+
+        case stereotype
+        when Array then stereotype.map(&:to_s)
+        when String then [stereotype]
+        when Symbol then [stereotype.to_s]
+        else [stereotype.to_s]
+        end
+      end
+
+      # Build a fully qualified name by walking the namespace chain of a UML element.
+      #
+      # @param uml_element [Lutaml::Uml::TopElement, Lutaml::Uml::Package] Any element with a namespace
+      # @return [String] Fully qualified name joined by '::'
+      #
+      # @example
+      #   qualified_name_for(class_in_package)  # => "ModelName::PackageName::ClassName"
+      def qualified_name_for(uml_element)
+        return uml_element.name unless uml_element.respond_to?(:namespace)
+
+        parts = []
+        current = uml_element
+
+        while current
+          parts.unshift(current.name) if current.name
+          current = if current.respond_to?(:namespace) && current.namespace
+                      current.namespace
+                    else
+                      break
+                    end
+        end
+
+        parts.join("::")
+      end
+
+      # Build a package-only namespace path (no class names).
+      #
+      # @param uml_element [Lutaml::Uml::TopElement, Lutaml::Uml::Package]
+      # @return [String] Package path joined by '::'
+      #
+      # @example
+      #   package_path_for(class_in_nested_package)  # => "ModelName::ParentPackage::ChildPackage"
+      def package_path_for(uml_element)
+        return uml_element.name unless uml_element.respond_to?(:namespace)
+
+        parts = []
+        current = uml_element
+
+        while current
+          if current.is_a?(Lutaml::Uml::Package)
+            parts.unshift(current.name) if current.name
+            current = current.namespace if current.respond_to?(:namespace)
+          elsif current.is_a?(Lutaml::Uml::TopElement)
+            # Stop at the first TopElement (class, enum, etc.) — namespace above is package
+            current = current.namespace if current.respond_to?(:namespace)
+          else
+            break
+          end
+        end
+
+        parts.join("::")
+      end
+
+      # Extract the leaf class name from a fully-qualified class name or class object.
+      #
+      # @param uml_class [String, Class] A class name string or a Lutaml::Uml::* class instance
+      # @return [String] The leaf class name
+      #
+      # @example
+      #   class_type_for("Lutaml::Uml::Class")    # => "Class"
+      #   class_type_for(some_enum_object)          # => "Enumeration"
+      def class_type_for(uml_class)
+        case uml_class
+        when String then uml_class.split("::").last
+        when Class then uml_class.name.split("::").last
+        else uml_class.class.name.split("::").last
+        end
+      end
+
+      # Format a cardinality object as a "min..max" string.
+      #
+      # @param cardinality [Lutaml::Uml::Cardinality, Hash, nil]
+      # @return [String, nil] Formatted cardinality string or nil
+      #
+      # @example
+      #   format_cardinality(Lutaml::Uml::Cardinality.new(min: 0, max: 5))  # => "0..5"
+      #   format_cardinality({min: 1, max: nil})                           # => "1..*"
+      def format_cardinality(cardinality)
+        return nil unless cardinality
+
+        min = cardinality.respond_to?(:min) ? cardinality.min : cardinality[:min]
+        max = cardinality.respond_to?(:max) ? cardinality.max : cardinality[:max]
+        return nil if min.nil? && max.nil?
+
+        min_str = min.nil? ? "0" : min.to_s
+        max_str = max.nil? ? "*" : max.to_s
+        "#{min_str}..#{max_str}"
+      end
+
+      # Parse a cardinality string or hash into a {min:, max:} hash.
+      #
+      # @param min [String, nil]
+      # @param max [String, nil]
+      # @return [Hash{Symbol => String, nil}] Hash with :min and :max keys
+      def parse_cardinality(min, max)
+        { min: min, max: max }
+      end
+    end
+  end
+end

data/lib/lutaml/uml/node/attribute.rb

@@ -23,8 +23,10 @@ module Lutaml
           @static = !!value
         end
 
+        VALID_ACCESS = %w[public private protected package].freeze
+
         def access=(value)
-          @access = value.to_s # TODO: Validate?
+          @access = value.to_s
         end
       end
     end

data/lib/lutaml/uml/node/class_node.rb

@@ -16,13 +16,13 @@ module Lutaml
         attr_reader :modifier, :members
 
         def modifier=(value)
-          @modifier = value.to_s # TODO: Validate?
+          @modifier = value.to_s
         end
 
         def members=(value) # rubocop:disable Metrics/MethodLength
           @members = value.to_a.map do |member|
-            type       = member.to_a[0][0] # TODO: This is dumb
-            attributes = member.to_a[0][1]
+            type       = member.keys.first
+            attributes = member.values.first
             attributes[:parent] = self
 
             case type

data/lib/lutaml/uml/operation.rb

@@ -3,10 +3,12 @@
 module Lutaml
   module Uml
     class Operation < TopElement
+      attribute :id, :string
       attribute :return_type, :string
       attribute :parameter_type, :string
 
       yaml do
+        map "id", to: :id
         map "return_type", to: :return_type
         map "parameter_type", to: :parameter_type
       end

data/lib/lutaml/uml_repository/class_lookup_index.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    # O(1) lookup index for UML classes by various identifiers.
+    #
+    # Replaces O(n) linear scans that were repeated across multiple
+    # transformer and serializer classes.
+    #
+    # @example
+    #   index = ClassLookupIndex.new(repository.classes_index)
+    #   index.by_xmi_id("EAID_123...")
+    #   index.by_object_id(42)
+    class ClassLookupIndex
+      def initialize(classes)
+        @by_xmi_id = {}
+        @by_object_id = {}
+
+        classes.each do |klass|
+          @by_xmi_id[klass.xmi_id] = klass if klass.xmi_id
+          if klass.respond_to?(:ea_object_id) && klass.ea_object_id
+            @by_object_id[klass.ea_object_id] = klass
+          end
+        end
+      end
+
+      # @param xmi_id [String]
+      # @return [Lutaml::Uml::Class, nil]
+      def by_xmi_id(xmi_id)
+        @by_xmi_id[xmi_id]
+      end
+
+      # @param object_id [String, Integer]
+      # @return [Lutaml::Uml::Class, nil]
+      def by_object_id(object_id)
+        @by_object_id[object_id]
+      end
+    end
+  end
+end