lutaml 0.10.0 → 0.10.2

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

@@ -3,6 +3,8 @@
 require_relative "base_transformer"
 require_relative "tagged_value_transformer"
 require_relative "instance_transformer"
+require_relative "enum_transformer"
+require_relative "data_type_transformer"
 require "lutaml/uml"
 
 module Lutaml
@@ -32,7 +34,7 @@ module Lutaml
 
             # Load stereotype from t_xref
             stereotype = load_stereotype(ea_package.ea_guid)
-            pkg.stereotype = stereotype if stereotype
+            pkg.stereotype = [stereotype] if stereotype
 
             # Note: Child packages and contents will be loaded separately
             # to avoid circular dependencies and allow lazy loading
@@ -97,30 +99,54 @@ module Lutaml
 
           ea_objects = rows.map { |row| Models::EaObject.from_db_row(row) }
 
-          # Transform classes - include ALL class-type objects,
-          # even without names
-          # Also include Text objects that appear on diagrams
-          # (EA exports these as classes in XMI)
           class_transformer = ClassTransformer.new(database)
+          enum_transformer = EnumTransformer.new(database)
+          data_type_transformer = DataTypeTransformer.new(database)
+          instance_transformer = InstanceTransformer.new(database)
+
           ea_objects.each do |ea_obj|
-            is_class_type = ea_obj.uml_class? || ea_obj.interface?
-            is_text_on_diagram = ea_obj.object_type == "Text" &&
-              appears_on_diagram?(ea_obj.ea_object_id)
+            if enum_object?(ea_obj)
+              uml_enum = enum_transformer.transform(ea_obj)
+              pkg.enums << uml_enum if uml_enum
+            elsif data_type_object?(ea_obj)
+              uml_dt = data_type_transformer.transform(ea_obj)
+              pkg.data_types << uml_dt if uml_dt
+            elsif class_object?(ea_obj)
+              uml_class = class_transformer.transform(ea_obj)
+              pkg.classes << uml_class if uml_class
+            elsif ea_obj.instance?
+              uml_instance = instance_transformer.transform(ea_obj)
+              pkg.instances << uml_instance if uml_instance
+            end
+          end
+        end
 
-            next unless is_class_type || is_text_on_diagram
+        # Check if an EA object should be classified as an enum.
+        # EA stores enums as either object_type="Enumeration" or
+        # object_type="Class" with stereotype="enumeration".
+        def enum_object?(ea_obj)
+          ea_obj.enumeration? || stereotype_is?(ea_obj, "enumeration")
+        end
 
-            uml_class = class_transformer.transform(ea_obj)
-            pkg.classes << uml_class if uml_class
-          end
+        # Check if an EA object should be classified as a data type.
+        def data_type_object?(ea_obj)
+          ea_obj.data_type?
+        end
 
-          # Transform instances (Object type)
-          instance_transformer = InstanceTransformer.new(database)
-          ea_objects.select(&:instance?).each do |ea_obj|
-            uml_instance = instance_transformer.transform(ea_obj)
-            pkg.instances << uml_instance if uml_instance
-          end
+        # Check if an EA object should be classified as a class.
+        def class_object?(ea_obj)
+          return false if enum_object?(ea_obj) || data_type_object?(ea_obj)
+
+          ea_obj.uml_class? || ea_obj.interface? ||
+            ea_obj.object_type == "Text" ||
+            ea_obj.object_type == "ProxyConnector"
+        end
+
+        # Check if an object's stereotype matches (case-insensitive).
+        def stereotype_is?(ea_obj, expected)
+          return false unless ea_obj.stereotype
 
-          # Note: Enums and DataTypes could be added similarly
+          ea_obj.stereotype.downcase == expected
         end
 
         # Load diagrams for a package

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require_relative "validation_result"
 
 module Lutaml
@@ -247,9 +248,13 @@ module Lutaml
 
           path_parts = []
           current_id = package_id
+          visited = Set.new
 
           # Walk up the parent chain to build full path
           while current_id && !current_id.zero?
+            break if visited.include?(current_id)
+
+            visited.add(current_id)
             package = database.packages.find { |p| p.package_id == current_id }
 
             if package

data/lib/lutaml/qea/verification/document_normalizer.rb

@@ -11,11 +11,10 @@ module Lutaml
         # @param document [Lutaml::Uml::Document] The document to normalize
         # @return [Lutaml::Uml::Document] A normalized copy
         def normalize(document)
-          normalized = deep_copy(document)
-          remove_xmi_ids(normalized)
-          sort_collections(normalized)
-          normalize_strings_in_document(normalized)
-          normalized
+          remove_xmi_ids(document)
+          sort_collections(document)
+          normalize_strings_in_document(document)
+          document
         end
 
         # Remove all XMI IDs from document
@@ -71,13 +70,6 @@ module Lutaml
 
         private
 
-        # Deep copy document to avoid modifying original
-        def deep_copy(document)
-          # Use YAML serialization for deep copy
-          yaml = document.to_yaml
-          Lutaml::Uml::Document.from_yaml(yaml)
-        end
-
         # Process packages recursively to remove XMI IDs
         def process_packages(packages) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
           packages.each do |package|

data/lib/lutaml/qea/verification/document_verifier.rb

@@ -65,23 +65,29 @@ module Lutaml
           result
         end
 
+        # Reset cached match results (call between verifications)
+        def reset_cache
+          @cached_class_matches = nil
+          @cached_package_matches = nil
+        end
+
         # Compare element counts
         #
         # @param xmi_doc [Lutaml::Uml::Document] XMI document
         # @param qea_doc [Lutaml::Uml::Document] QEA document
         # @return [void]
         def verify_structure(xmi_doc, qea_doc) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          # Compare package counts
-          match_result = matcher.match_packages(xmi_doc, qea_doc)
-          result.add_matches(:packages, match_result[:matches].size)
-          result.add_xmi_only(:packages, match_result[:xmi_only])
-          result.add_qea_only(:packages, match_result[:qea_only])
-
-          # Compare class counts
-          match_result = matcher.match_classes(xmi_doc, qea_doc)
-          result.add_matches(:classes, match_result[:matches].size)
-          result.add_xmi_only(:classes, match_result[:xmi_only])
-          result.add_qea_only(:classes, match_result[:qea_only])
+          # Compare package counts (cache for reuse in verify_properties)
+          @cached_package_matches = matcher.match_packages(xmi_doc, qea_doc)
+          result.add_matches(:packages, @cached_package_matches[:matches].size)
+          result.add_xmi_only(:packages, @cached_package_matches[:xmi_only])
+          result.add_qea_only(:packages, @cached_package_matches[:qea_only])
+
+          # Compare class counts (cache for reuse in verify_properties)
+          @cached_class_matches = matcher.match_classes(xmi_doc, qea_doc)
+          result.add_matches(:classes, @cached_class_matches[:matches].size)
+          result.add_xmi_only(:classes, @cached_class_matches[:xmi_only])
+          result.add_qea_only(:classes, @cached_class_matches[:qea_only])
 
           # Compare enum counts
           xmi_enums = count_all_enums(xmi_doc)
@@ -130,12 +136,16 @@ module Lutaml
         # @param qea_doc [Lutaml::Uml::Document] QEA document
         # @return [void]
         def verify_properties(xmi_doc, qea_doc)
-          # Verify class properties
-          class_matches = matcher.match_classes(xmi_doc, qea_doc)
+          # Verify class properties (reuse cached matches from verify_structure)
+          class_matches = @cached_class_matches || matcher.match_classes(
+            xmi_doc, qea_doc
+          )
           verify_class_properties(class_matches[:matches])
 
-          # Verify package properties
-          package_matches = matcher.match_packages(xmi_doc, qea_doc)
+          # Verify package properties (reuse cached matches from verify_structure)
+          package_matches = @cached_package_matches || matcher.match_packages(
+            xmi_doc, qea_doc
+          )
           verify_package_properties(package_matches[:matches])
         end
 

data/lib/lutaml/uml_repository/index_builder.rb

@@ -388,20 +388,38 @@ module Lutaml
 
         classes.each do |klass|
           next unless klass.name
-          next unless klass.generalization
 
           child_qname = "#{package_path}::#{klass.name}"
 
-          # Handle generalization - it could have a general attribute
-          parent_name = extract_parent_name(klass.generalization)
-          next unless parent_name
+          # Handle generalization attribute
+          if klass.generalization
+            parent_name = extract_parent_name(klass.generalization)
+            if parent_name
+              parent_qname = resolve_qualified_name(parent_name, package_path)
+              if parent_qname && child_qname != parent_qname
+                @inheritance_graph[parent_qname] ||= []
+                @inheritance_graph[parent_qname] << child_qname
+              end
+            end
+          end
+
+          # Handle inheritance associations
+          next unless klass.associations
+
+          klass.associations.each do |assoc|
+            next unless assoc.respond_to?(:member_end_type)
+            next unless assoc.member_end_type == "inheritance"
+
+            parent_name = assoc.member_end
+            next unless parent_name
+
+            parent_name = parent_name.name if parent_name.respond_to?(:name)
+            next unless parent_name.is_a?(String) && !parent_name.empty?
 
-          # Try to resolve parent qualified name
-          parent_qname = resolve_qualified_name(parent_name, package_path)
-          next unless parent_qname
+            parent_qname = resolve_qualified_name(parent_name, package_path)
+            next unless parent_qname
+            next if child_qname == parent_qname
 
-          # Avoid self-references
-          if child_qname != parent_qname
             @inheritance_graph[parent_qname] ||= []
             @inheritance_graph[parent_qname] << child_qname
           end

data/lib/lutaml/uml_repository/package_exporter.rb

@@ -76,9 +76,22 @@ module Lutaml
       # @raise [ArgumentError] If serialization format is invalid
       # @example
       #   exporter.export("model.lur")
-      def export(output_path)
+      def export(output_path) # rubocop:disable Metrics/MethodLength
         validate_options!
 
+        retries = 0
+        begin
+          write_lur_package(output_path)
+        rescue Errno::EACCES
+          retries += 1
+          retry if retries < 3
+          raise
+        end
+      end
+
+      private
+
+      def write_lur_package(output_path)
         Zip::File.open(output_path, create: true) do |zip|
           write_metadata(zip)
           write_document(zip)
@@ -88,8 +101,6 @@ module Lutaml
         end
       end
 
-      private
-
       # Get default export options.
       #
       # @return [Hash] Default options

data/lib/lutaml/uml_repository/presenters/diagram_presenter.rb

@@ -424,14 +424,9 @@ module Lutaml
           return nil unless uml_element.respond_to?(:stereotype)
 
           stereotype = uml_element.stereotype
-          return nil unless stereotype
+          return nil unless stereotype && !stereotype.empty?
 
-          # Handle array of stereotypes
-          if stereotype.is_a?(Array)
-            stereotype.first
-          else
-            stereotype
-          end
+          stereotype.is_a?(Array) ? stereotype.first : stereotype
         end
 
         # Extract attributes from element

data/lib/lutaml/uml_repository/queries/inheritance_query.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require_relative "base_query"
 require_relative "../../uml/qualified_name"
 
@@ -171,8 +172,73 @@ module Lutaml
           qname.nil? ? nil : qname
         end
 
+        # Build inheritance tree for a class.
+        #
+        # @param class_or_id [Lutaml::Uml::Class, String] The class object,
+        #   qualified name, or xmi_id
+        # @return [Hash, nil] Tree structure with :class and :children keys
+        def inheritance_tree(class_or_id)
+          klass = resolve_by_id_or_qname(class_or_id)
+          return nil unless klass
+
+          qname = resolve_qname(klass)
+          return nil unless qname
+
+          child_qnames = indexes[:inheritance_graph][qname] || []
+          child_trees = child_qnames.filter_map do |child_qname|
+            inheritance_tree(child_qname)
+          end
+
+          {
+            class: klass,
+            children: child_trees,
+          }
+        end
+
+        # Check if a class has circular inheritance.
+        #
+        # @param class_or_id [Lutaml::Uml::Class, String] The class object,
+        #   qualified name, or xmi_id
+        # @return [Boolean] true if circular inheritance detected
+        def has_circular_inheritance?(class_or_id, visited: Set.new)
+          qname = if class_or_id.is_a?(String) &&
+              indexes[:qualified_names].key?(class_or_id)
+                    class_or_id
+                  else
+                    resolve_qname(class_or_id)
+                  end
+          return false unless qname
+
+          return true if visited.include?(qname)
+
+          visited.add(qname)
+          child_qnames = indexes[:inheritance_graph][qname] || []
+          child_qnames.any? do |child_qname|
+            has_circular_inheritance?(child_qname, visited: visited.dup)
+          end
+        end
+
         private
 
+        # Resolve a class by xmi_id or qualified name
+        #
+        # @param class_or_id [String] Qualified name or xmi_id
+        # @return [Lutaml::Uml::Class, nil] The resolved class
+        def resolve_by_id_or_qname(class_or_id)
+          # Try as qualified name first
+          klass = indexes[:qualified_names][class_or_id]
+          return klass if klass
+
+          # Try as xmi_id - search in qualified_names
+          indexes[:qualified_names].each_value do |entity|
+            next unless entity.respond_to?(:xmi_id)
+
+            return entity if entity.xmi_id == class_or_id
+          end
+
+          nil
+        end
+
         # Get direct subtypes of a class
         #
         # @param qname_string [String] Qualified name of the parent class

data/lib/lutaml/uml_repository/queries/search_query.rb

@@ -158,7 +158,7 @@ module Lutaml
             .filter_map do |_stereotype, entities|
             entities.select do |entity|
               entity.respond_to?(:stereotype) &&
-                entity.stereotype&.match?(pattern)
+                Array(entity.stereotype).any? { |s| s&.match?(pattern) }
             end.uniq
           end.uniq.flatten
 

data/lib/lutaml/uml_repository/repository.rb

@@ -345,6 +345,40 @@ module Lutaml
         @error_handler.class_not_found_error(qualified_name)
       end
 
+      # Find an attribute by its qualified name.
+      #
+      # The qualified name format is "PackagePath::ClassName::attributeName".
+      # Splits off the last segment as the attribute name, finds the containing
+      # class, then returns the matching attribute.
+      #
+      # @param qualified_name [String] Qualified name of the attribute
+      # @return [Lutaml::Uml::Attribute, nil] The attribute or nil
+      # @example
+      #   attr = repo.find_attribute("ModelRoot::Core::Building::name")
+      def find_attribute(qualified_name)
+        class_qname, _, attr_name = qualified_name.rpartition("::")
+        return nil if class_qname.empty?
+
+        klass = class_query.find_by_qname(class_qname)
+        return nil unless klass
+
+        attrs = klass.attributes
+        return nil unless attrs
+
+        attrs.find { |a| a.name == attr_name }
+      end
+
+      # Get all attributes across all classes in the repository.
+      #
+      # @return [Array<Lutaml::Uml::Attribute>] All attribute objects
+      def all_attributes
+        indexes[:qualified_names].flat_map do |_qname, entity|
+          next [] unless entity.respond_to?(:attributes) && entity.attributes
+
+          entity.attributes
+        end
+      end
+
       # Find all classes with a specific stereotype.
       #
       # @param stereotype [String] The stereotype to search for

data/lib/lutaml/uml_repository/validators/repository_validator.rb

@@ -48,7 +48,7 @@ module Lutaml
 
           check_type_references
           check_generalization_references
-          # DISABLED: check_circular_inheritance - has bugs with name resolution
+          check_circular_inheritance
           check_association_references
           check_multiplicities
 

data/lib/lutaml/uml_repository/web_ui/app.rb

@@ -76,13 +76,31 @@ module Lutaml
         # API: Package details (on-demand, optional optimization)
         get "/api/packages/:id" do
           content_type :json
-          params[:id]
-
-          # Find package by generated ID
-          # This would require reverse lookup from ID to package
-          # For now, use the full data endpoint
-          halt 501, { error: "On-demand package loading not yet implemented. " \
-                             "Use /api/data" }.to_json
+          requested_id = params[:id]
+
+          id_gen = UmlRepository::StaticSite::IDGenerator.new
+
+          # Search for package by matching generated ID
+          found_package = nil
+          repository.indexes[:package_paths].each_value do |package|
+            next unless package.is_a?(Lutaml::Uml::Package)
+
+            if id_gen.package_id(package) == requested_id
+              found_package = package
+              break
+            end
+          end
+
+          unless found_package
+            halt 404, { error: "Package not found: #{requested_id}" }.to_json
+          end
+
+          # Build package response
+          {
+            id: requested_id,
+            name: found_package.name,
+            xmi_id: found_package.xmi_id,
+          }.to_json
         end
 
         # API: Class details (on-demand, optional optimization)

data/lib/lutaml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lutaml
-  VERSION = "0.10.0"
+  VERSION = "0.10.2"
 end