lutaml 0.10.13 → 0.10.15

data/lib/lutaml/uml_repository/static_site/data_transformer.rb

@@ -33,24 +33,13 @@ module Lutaml
         def transform
           Models::SpaDocument.new(
             metadata: Serializers::MetadataBuilder.new(repository).build,
-            package_tree: Serializers::PackageTreeBuilder.new(repository,
-                                                              id_generator).build,
-            packages: Serializers::PackageSerializer.new(repository,
-                                                         id_generator, options).build_map,
-            classes: Serializers::ClassSerializer.new(repository, id_generator,
-                                                      options, inheritance_resolver).build_map,
-            attributes: Serializers::AttributeSerializer.new(repository,
-                                                             id_generator, options).build_map,
+            package_tree: build_package_tree,
+            packages: build_packages_map,
+            classes: build_classes_map,
+            attributes: build_attributes_map,
             associations: build_associations_map,
-            operations: Serializers::OperationSerializer.new(repository,
-                                                             id_generator).build_map,
-            diagrams: if options[:include_diagrams]
-                        Serializers::DiagramSerializer.new(
-                          repository, id_generator, options
-                        ).build_map
-                      else
-                        {}
-                      end,
+            operations: build_operations_map,
+            diagrams: build_diagrams_map,
           )
         end
 
@@ -74,24 +63,7 @@ module Lutaml
           map = Hash.new { |h, k| h[k] = [] }
 
           repository.classes_index.each do |klass|
-            next unless klass.association_generalization
-            unless klass.association_generalization && !klass.association_generalization.empty?
-              next
-            end
-
-            klass.association_generalization.each do |assoc_gen|
-              parent_object_id = assoc_gen.parent_object_id
-              next unless parent_object_id
-
-              parent_class = class_lookup.by_object_id(parent_object_id)
-              if parent_class&.xmi_id
-                next if parent_class.xmi_id == klass.xmi_id
-
-                unless map[klass.xmi_id].include?(parent_class.xmi_id)
-                  map[klass.xmi_id] << parent_class.xmi_id
-                end
-              end
-            end
+            add_generalization_entries(map, klass)
           end
 
           map
@@ -101,6 +73,63 @@ module Lutaml
           @class_lookup ||= ClassLookupIndex.new(repository.classes_index)
         end
 
+        def build_package_tree
+          Serializers::PackageTreeBuilder.new(repository, id_generator).build
+        end
+
+        def build_packages_map
+          Serializers::PackageSerializer.new(repository, id_generator,
+                                             options).build_map
+        end
+
+        def build_classes_map
+          Serializers::ClassSerializer.new(repository, id_generator,
+                                           options, inheritance_resolver).build_map
+        end
+
+        def build_attributes_map
+          Serializers::AttributeSerializer.new(repository, id_generator,
+                                               options).build_map
+        end
+
+        def build_operations_map
+          Serializers::OperationSerializer.new(repository,
+                                               id_generator).build_map
+        end
+
+        def build_diagrams_map
+          return {} unless options[:include_diagrams]
+
+          Serializers::DiagramSerializer.new(repository, id_generator,
+                                             options).build_map
+        end
+
+        def add_generalization_entries(map, klass)
+          return unless klass.association_generalization
+          return if klass.association_generalization.empty?
+
+          klass.association_generalization.each do |assoc_gen|
+            add_valid_generalization_entry(map, klass, assoc_gen)
+          end
+        end
+
+        def add_valid_generalization_entry(map, klass, assoc_gen)
+          parent_xmi_id = resolve_parent_xmi_id(assoc_gen)
+          return unless parent_xmi_id
+          return if parent_xmi_id == klass.xmi_id
+          return if map[klass.xmi_id].include?(parent_xmi_id)
+
+          map[klass.xmi_id] << parent_xmi_id
+        end
+
+        def resolve_parent_xmi_id(assoc_gen)
+          parent_object_id = assoc_gen.parent_object_id
+          return nil unless parent_object_id
+
+          parent_class = class_lookup.by_object_id(parent_object_id)
+          parent_class&.xmi_id
+        end
+
         def format_definition(definition)
           return nil if definition.nil? || definition.empty?
 

data/lib/lutaml/uml_repository/static_site/search_index_builder.rb

@@ -51,23 +51,9 @@ module Lutaml
 
         def build_document_store
           documents = []
-
-          repository.classes_index.each do |klass|
-            documents << build_class_document(klass)
-
-            klass.attributes&.each do |attr|
-              documents << build_attribute_document(attr, klass)
-            end
-          end
-
-          repository.associations_index.each do |assoc|
-            documents << build_association_document(assoc)
-          end
-
-          repository.packages_index.each do |package|
-            documents << build_package_document(package)
-          end
-
+          documents.concat(build_class_documents)
+          documents.concat(build_association_documents)
+          documents.concat(build_package_documents)
           documents
         end
 
@@ -135,8 +121,8 @@ module Lutaml
             class_type(klass),
             Array(klass.stereotype).join(" "),
             klass.definition,
-            klass.attributes&.map(&:name)&.join(" "),
-            klass.operations&.map(&:name)&.join(" "),
+            collect_names(klass.attributes),
+            collect_names(klass.operations),
           ].compact
 
           normalize_content(parts.join(" "))
@@ -186,6 +172,33 @@ module Lutaml
           all_content.join(" ").gsub(/\s+/, " ").strip
         end
 
+        def build_class_documents
+          docs = []
+          repository.classes_index.each do |klass|
+            docs << build_class_document(klass)
+            klass.attributes&.each do |attr|
+              docs << build_attribute_document(attr, klass)
+            end
+          end
+          docs
+        end
+
+        def build_association_documents
+          repository.associations_index.map do |assoc|
+            build_association_document(assoc)
+          end
+        end
+
+        def build_package_documents
+          repository.packages_index.map do |package|
+            build_package_document(package)
+          end
+        end
+
+        def collect_names(items)
+          items&.map(&:name)&.join(" ")
+        end
+
         def class_type(klass)
           klass.class.name.split("::").last
         end

data/lib/lutaml/uml_repository/static_site/serializers/class_serializer.rb

@@ -30,10 +30,7 @@ inheritance_resolver)
 
           private
 
-          def serialize(klass, id) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-            class_associations = find_class_associations(klass)
-            sorted_associations = sort_associations(class_associations, klass)
-
+          def serialize(klass, id)
             Models::SpaClass.new(
               id: id,
               xmi_id: klass.xmi_id,
@@ -43,17 +40,38 @@ inheritance_resolver)
               package: package_id_for_class(klass),
               stereotypes: normalize_stereotypes(klass.stereotype),
               definition: format_definition(klass.definition),
-              attributes: (klass.attributes || []).sort_by { |a| a.name || "" }
-                .map { |attr| @id_generator.attribute_id(attr, klass) },
+              attributes: serialize_attribute_ids(klass),
               operations: serialize_class_operations(klass),
-              associations: sorted_associations,
-              generalizations: @inheritance_resolver.find_generalizations(klass),
-              specializations: @inheritance_resolver.find_specializations(klass),
+              associations: sort_associations(find_class_associations(klass),
+                                              klass),
               is_abstract: klass.is_abstract,
               literals: serialize_literals(klass),
+              **inheritance_data(klass),
+            )
+          end
+
+          def inheritance_data(klass)
+            {
+              generalizations: @inheritance_resolver.find_generalizations(klass),
+              specializations: @inheritance_resolver.find_specializations(klass),
               inherited_attributes: @inheritance_resolver.compute_inherited_attributes(klass),
               inherited_associations: @inheritance_resolver.compute_inherited_associations(klass),
-            )
+            }
+          end
+
+          def resolve_assoc_role(assoc, klass)
+            if assoc.owner_end_xmi_id == klass.xmi_id
+              assoc.owner_end_attribute_name || assoc.owner_end || ""
+            elsif assoc.member_end_xmi_id == klass.xmi_id
+              assoc.member_end_attribute_name || assoc.member_end || ""
+            else
+              ""
+            end
+          end
+
+          def serialize_attribute_ids(klass)
+            (klass.attributes || []).sort_by { |a| a.name || "" }
+              .map { |attr| @id_generator.attribute_id(attr, klass) }
           end
 
           def find_class_associations(klass)
@@ -65,18 +83,16 @@ inheritance_resolver)
 
           def sort_associations(assoc_ids, klass)
             assoc_ids.sort_by do |assoc_id|
-              assoc = @repository.associations_index.find do |a|
-                @id_generator.association_id(a) == assoc_id
-              end
+              assoc = find_assoc_by_id(assoc_id)
               next "" unless assoc
 
-              if assoc.owner_end_xmi_id == klass.xmi_id
-                assoc.owner_end_attribute_name || assoc.owner_end || ""
-              elsif assoc.member_end_xmi_id == klass.xmi_id
-                assoc.member_end_attribute_name || assoc.member_end || ""
-              else
-                ""
-              end
+              resolve_assoc_role(assoc, klass)
+            end
+          end
+
+          def find_assoc_by_id(assoc_id)
+            @repository.associations_index.find do |a|
+              @id_generator.association_id(a) == assoc_id
             end
           end
 

data/lib/lutaml/uml_repository/static_site/serializers/inheritance_resolver.rb

@@ -22,17 +22,8 @@ module Lutaml
           end
 
           def find_generalizations(klass)
-            parent_xmi_ids = @generalization_map[klass.xmi_id]
-
-            if parent_xmi_ids && !parent_xmi_ids.empty?
-              parents = parent_xmi_ids.filter_map do |parent_xmi_id|
-                next if parent_xmi_id == klass.xmi_id
-
-                parent = class_lookup.by_xmi_id(parent_xmi_id)
-                parent ? @id_generator.class_id(parent) : nil
-              end
-              return parents unless parents.empty?
-            end
+            map_parents = generalization_map_parents(klass)
+            return map_parents unless map_parents.nil?
 
             parent = @repository.supertype_of(klass)
             return [] if parent && parent.xmi_id == klass.xmi_id
@@ -52,12 +43,59 @@ module Lutaml
           end
 
           def compute_inherited_attributes(klass, visited = Set.new)
+            walk_inheritance_chain(klass, visited, :parent_inherited_attrs)
+          rescue StandardError => e
+            warn "Error computing inherited attributes: #{e.message}"
+            []
+          end
+
+          def compute_inherited_associations(klass, visited = Set.new)
+            walk_inheritance_chain(klass, visited, :parent_inherited_assocs)
+          rescue StandardError => e
+            warn "Error computing inherited associations: #{e.message}"
+            []
+          end
+
+          def serialize_generalization(klass, visited = Set.new)
+            return nil unless klass.generalization
+            return nil if visited.include?(klass.xmi_id)
+
+            visited.add(klass.xmi_id)
+            gen = klass.generalization
+
+            gen_basic_fields(gen).merge(gen_collection_fields(gen))
+          rescue StandardError => e
+            warn "Error serializing generalization: #{e.message}"
+            nil
+          end
+
+          def serialize_general_attribute(attr)
+            return nil unless attr
+
+            {
+              name: attr.name,
+              type: attr.type,
+              cardinality: serialize_cardinality(attr.cardinality),
+              definition: format_definition(attr.definition),
+              upperKlass: attr.upper_klass,
+              nameNs: attr.name_ns,
+              typeNs: attr.type_ns,
+            }
+          end
+
+          private
+
+          def walk_inheritance_chain(klass, visited, collector_method)
             return [] unless klass.generalization
             return [] if visited.include?(klass.xmi_id)
 
             visited.add(klass.xmi_id)
+            collect_chain_items(klass.generalization, visited, collector_method)
+          end
+
+          def collect_chain_items(starting_gen, visited, collector_method)
             inherited = []
-            current_gen = klass.generalization
+            current_gen = starting_gen
             parent_order = 0
 
             while current_gen
@@ -66,127 +104,93 @@ module Lutaml
               break if visited.include?(parent_class.xmi_id)
 
               visited.add(parent_class.xmi_id)
-
-              if parent_class.attributes
-                sorted_attrs = parent_class.attributes.sort_by do |a|
-                  a.name || ""
-                end
-                sorted_attrs.each do |attr|
-                  attr_id = @id_generator.attribute_id(attr, parent_class)
-                  inherited << Models::SpaInheritedAttribute.new(
-                    attribute_id: attr_id,
-                    attribute: serialize_attribute(attr, parent_class, attr_id),
-                    inherited_from: @id_generator.class_id(parent_class),
-                    inherited_from_name: parent_class.name,
-                    parent_order: parent_order,
-                  )
-                end
-              end
+              inherited.concat(send(collector_method, parent_class,
+                                    parent_order))
 
               parent_order += 1
               current_gen = current_gen.general
             end
 
             inherited
-          rescue StandardError => e
-            warn "Error computing inherited attributes: #{e.message}"
-            []
           end
 
-          def compute_inherited_associations(klass, visited = Set.new)
-            return [] unless klass.generalization
-            return [] if visited.include?(klass.xmi_id)
+          def generalization_map_parents(klass)
+            parent_xmi_ids = @generalization_map[klass.xmi_id]
+            return nil if parent_xmi_ids.nil? || parent_xmi_ids.empty?
 
-            visited.add(klass.xmi_id)
-            inherited = []
-            current_gen = klass.generalization
-            parent_order = 0
+            parents = parent_xmi_ids.filter_map do |parent_xmi_id|
+              next if parent_xmi_id == klass.xmi_id
 
-            while current_gen
-              parent_class = class_lookup.by_xmi_id(current_gen.general_id)
-              break unless parent_class
-              break if visited.include?(parent_class.xmi_id)
+              resolve_parent_class_id(parent_xmi_id)
+            end
+            parents.empty? ? nil : parents
+          end
 
-              visited.add(parent_class.xmi_id)
-              parent_associations = find_class_associations(parent_class)
-
-              assoc_with_roles = parent_associations.filter_map do |assoc_id|
-                assoc = @repository.associations_index.find do |a|
-                  @id_generator.association_id(a) == assoc_id
-                end
-                next unless assoc
-
-                local_role = if assoc.owner_end_xmi_id == parent_class.xmi_id
-                               assoc.owner_end_attribute_name || assoc.owner_end || ""
-                             elsif assoc.member_end_xmi_id == parent_class.xmi_id
-                               assoc.member_end_attribute_name || assoc.member_end || ""
-                             else
-                               ""
-                             end
-                { id: assoc_id, role: local_role }
-              end
+          def resolve_parent_class_id(parent_xmi_id)
+            parent = class_lookup.by_xmi_id(parent_xmi_id)
+            parent ? @id_generator.class_id(parent) : nil
+          end
 
-              assoc_with_roles.sort_by { |a| a[:role] }.each do |item|
-                inherited << Models::SpaInheritedAssociation.new(
-                  association_id: item[:id],
+          def parent_inherited_attrs(parent_class, parent_order)
+            return [] unless parent_class.attributes
+
+            parent_class.attributes.sort_by { |a| a.name || "" }
+              .map do |attr|
+                attr_id = @id_generator.attribute_id(attr, parent_class)
+                Models::SpaInheritedAttribute.new(
+                  attribute_id: attr_id,
+                  attribute: serialize_attribute(attr, parent_class, attr_id),
                   inherited_from: @id_generator.class_id(parent_class),
                   inherited_from_name: parent_class.name,
                   parent_order: parent_order,
-                  local_role: item[:role],
                 )
               end
+          end
 
-              parent_order += 1
-              current_gen = current_gen.general
-            end
+          def parent_inherited_assocs(parent_class, parent_order)
+            assoc_with_roles = collect_assoc_roles(parent_class)
 
-            inherited
-          rescue StandardError => e
-            warn "Error computing inherited associations: #{e.message}"
-            []
+            assoc_with_roles.sort_by { |a| a[:role] }.map do |item|
+              build_inherited_assoc(item, parent_class, parent_order)
+            end
           end
 
-          def serialize_generalization(klass, visited = Set.new)
-            return nil unless klass.generalization
-            return nil if visited.include?(klass.xmi_id)
+          def collect_assoc_roles(parent_class)
+            find_class_associations(parent_class).filter_map do |assoc_id|
+              assoc = find_assoc_by_generated_id(assoc_id)
+              next unless assoc
 
-            visited.add(klass.xmi_id)
-            gen = klass.generalization
+              { id: assoc_id, role: resolve_local_role(assoc, parent_class) }
+            end
+          end
 
-            {
-              generalId: gen.general_id,
-              generalName: gen.general_name,
-              generalUpperKlass: gen.general_upper_klass,
-              hasGeneral: gen.has_general,
-              name: gen.name,
-              type: gen.type,
-              definition: format_definition(gen.definition),
-              stereotype: gen.stereotype,
-              ownedProps: serialize_general_collection(gen.owned_props),
-              assocProps: serialize_general_collection(gen.assoc_props),
-              inheritedProps: serialize_general_collection(gen.inherited_props),
-              inheritedAssocProps: serialize_general_collection(gen.inherited_assoc_props),
-            }
-          rescue StandardError => e
-            warn "Error serializing generalization: #{e.message}"
-            nil
+          def find_assoc_by_generated_id(assoc_id)
+            @repository.associations_index.find do |a|
+              @id_generator.association_id(a) == assoc_id
+            end
           end
 
-          def serialize_general_attribute(attr)
-            return nil unless attr
+          def build_inherited_assoc(item, parent_class, parent_order)
+            Models::SpaInheritedAssociation.new(
+              association_id: item[:id],
+              inherited_from: @id_generator.class_id(parent_class),
+              inherited_from_name: parent_class.name,
+              parent_order: parent_order,
+              local_role: item[:role],
+            )
+          end
 
-            {
-              name: attr.name,
-              type: attr.type,
-              cardinality: serialize_cardinality(attr.cardinality),
-              definition: format_definition(attr.definition),
-              upperKlass: attr.upper_klass,
-              nameNs: attr.name_ns,
-              typeNs: attr.type_ns,
-            }
+          def resolve_local_role(assoc, parent_class)
+            role_for_end(assoc, parent_class.xmi_id) || ""
           end
 
-          private
+          def role_for_end(assoc, xmi_id)
+            if assoc.owner_end_xmi_id == xmi_id
+              assoc.owner_end_attribute_name || assoc.owner_end
+            elsif assoc.member_end_xmi_id == xmi_id
+              assoc.member_end_attribute_name || assoc.member_end
+            end
+          end
 
           def class_lookup
             @class_lookup ||= ClassLookupIndex.new(@repository.classes_index)
@@ -231,6 +235,28 @@ module Lutaml
             )
           end
 
+          def gen_basic_fields(gen)
+            {
+              generalId: gen.general_id,
+              generalName: gen.general_name,
+              generalUpperKlass: gen.general_upper_klass,
+              hasGeneral: gen.has_general,
+              name: gen.name,
+              type: gen.type,
+              definition: format_definition(gen.definition),
+              stereotype: gen.stereotype,
+            }
+          end
+
+          def gen_collection_fields(gen)
+            {
+              ownedProps: serialize_general_collection(gen.owned_props),
+              assocProps: serialize_general_collection(gen.assoc_props),
+              inheritedProps: serialize_general_collection(gen.inherited_props),
+              inheritedAssocProps: serialize_general_collection(gen.inherited_assoc_props),
+            }
+          end
+
           def format_definition(definition)
             return nil if definition.nil? || definition.empty?
 

data/lib/lutaml/uml_repository/static_site/serializers/package_serializer.rb

@@ -35,19 +35,25 @@ module Lutaml
               path: package_path(package),
               definition: format_definition(package.definition),
               stereotypes: normalize_stereotypes(package.stereotype),
-              classes: (package.classes || []).map do |c|
-                @id_generator.class_id(c)
-              end,
-              sub_packages: (package.packages || []).map do |p|
-                @id_generator.package_id(p)
-              end,
-              diagrams: package_diagrams(package).map do |d|
-                @id_generator.diagram_id(d)
-              end,
+              classes: collect_class_ids(package),
+              sub_packages: collect_sub_package_ids(package),
+              diagrams: collect_diagram_ids(package),
               parent: parent_id(package),
             )
           end
 
+          def collect_class_ids(package)
+            (package.classes || []).map { |c| @id_generator.class_id(c) }
+          end
+
+          def collect_sub_package_ids(package)
+            (package.packages || []).map { |p| @id_generator.package_id(p) }
+          end
+
+          def collect_diagram_ids(package)
+            package_diagrams(package).map { |d| @id_generator.diagram_id(d) }
+          end
+
           def parent_id(package)
             return nil unless package.namespace.is_a?(Lutaml::Uml::Package)