lutaml 0.10.4 → 0.10.6

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

@@ -11,6 +11,27 @@ require_relative "id_generator"
 module Lutaml
   module UmlRepository
     module StaticSite
+      # Resolves Liquid {% include %} paths to template files on disk.
+      # Unlike LocalFileSystem (which adds a "_" prefix), this resolves
+      # paths directly: "components/header" → "<root>/components/header.liquid"
+      class TemplateFileSystem
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def read_template_file(template_path)
+          full = File.expand_path("#{template_path}.liquid", @root)
+          unless full.start_with?(@root)
+            raise Liquid::FileSystemError,
+                  "Illegal template path: #{template_path}"
+          end
+
+          File.read(full)
+        end
+      end
+
       # Main static site generator for LutaML UML Browser.
       #
       # Follows Dependency Inversion Principle by injecting dependencies
@@ -163,12 +184,9 @@ module Lutaml
         end
 
         def setup_liquid
-          # Use environment instead of deprecated class-level setters
-          environment = Liquid::Environment.new
-          environment.file_system = Liquid::LocalFileSystem.new(@options[:template_path])
-          # Changed from :strict to handle missing includes
-          environment.error_mode = :lax
-          @liquid_environment = environment
+          @liquid_environment = Liquid::Environment.new
+          @liquid_environment.file_system = TemplateFileSystem.new(@options[:template_path])
+          @liquid_environment.error_mode = :lax
         end
 
         # Generate single-file SPA
@@ -226,7 +244,7 @@ module Lutaml
 
         def render_components # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
           # Set up Liquid file system for recursive includes
-          temp_file_system = Liquid::LocalFileSystem.new(@options[:template_path])
+          temp_file_system = TemplateFileSystem.new(@options[:template_path])
 
           component_names = ["header", "sidebar", "content", "package_details",
                              "class_details"]
@@ -274,7 +292,10 @@ module Lutaml
           # Render and write index.html
           template_content = File.read(File.join(@options[:template_path],
                                                  "multi_file.liquid"))
-          template = Liquid::Template.parse(template_content)
+          file_system = TemplateFileSystem.new(@options[:template_path])
+          template = Liquid::Template.parse(template_content,
+                                            error_mode: :lax)
+          template.registers[:file_system] = file_system
           html = template.render(context)
           html = minify_html(html) if @options[:minify]
           File.write(File.join(output_dir, "index.html"), html)

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

@@ -271,10 +271,7 @@ module Lutaml
           current = klass
 
           while current
-            if current.is_a?(Lutaml::Uml::TopElement)
-              path_parts.unshift(current.name)
-              current = current.namespace if current.respond_to?(:namespace)
-            elsif current.is_a?(Lutaml::Uml::Package)
+            if current.is_a?(Lutaml::Uml::TopElement) || current.is_a?(Lutaml::Uml::Package)
               path_parts.unshift(current.name)
               current = current.namespace if current.respond_to?(:namespace)
             else

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../../../uml/model_helpers"
+
+module Lutaml
+  module UmlRepository
+    module StaticSite
+      module Serializers
+        class AttributeSerializer
+          include Lutaml::Uml::ModelHelpers
+
+          def initialize(repository, id_generator, options)
+            @repository = repository
+            @id_generator = id_generator
+            @options = options
+          end
+
+          def build_map
+            attributes = {}
+            @repository.classes_index.each do |klass|
+              next unless klass.attributes
+
+              klass.attributes.each do |attr|
+                id = @id_generator.attribute_id(attr, klass)
+                attributes[id] = serialize(attr, klass, id)
+              end
+            end
+            attributes
+          end
+
+          def serialize(attribute, owner, id)
+            {
+              id: id,
+              name: attribute.name,
+              type: attribute.type,
+              visibility: attribute.visibility,
+              owner: @id_generator.class_id(owner),
+              ownerName: owner.name,
+              cardinality: serialize_cardinality(attribute.cardinality),
+              definition: format_definition(attribute.definition),
+              stereotypes: normalize_stereotypes(
+                attribute.respond_to?(:stereotype) ? attribute.stereotype : nil,
+              ),
+              isStatic: attribute.respond_to?(:is_static) ? attribute.is_static : false,
+              isReadOnly: attribute.respond_to?(:is_read_only) ? attribute.is_read_only : false,
+              defaultValue: attribute.respond_to?(:default) ? attribute.default : nil,
+            }
+          end
+
+          private
+
+          def serialize_cardinality(cardinality)
+            return nil unless cardinality
+
+            {
+              min: cardinality.min,
+              max: cardinality.max,
+            }
+          end
+
+          def format_definition(definition)
+            return nil if definition.nil? || definition.empty?
+
+            formatted = definition.strip
+            if @options[:max_definition_length] &&
+                formatted.length > @options[:max_definition_length]
+              formatted = "#{formatted[0...@options[:max_definition_length]]}..."
+            end
+            if @options[:format_definitions]
+              formatted = formatted.gsub(%r{(https?://[^\s]+)}, '[\1](\1)')
+            end
+            formatted
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "../../../uml/model_helpers"
+
+module Lutaml
+  module UmlRepository
+    module StaticSite
+      module Serializers
+        class ClassSerializer
+          include Lutaml::Uml::ModelHelpers
+
+          def initialize(repository, id_generator, options,
+inheritance_resolver)
+            @repository = repository
+            @id_generator = id_generator
+            @options = options
+            @inheritance_resolver = inheritance_resolver
+          end
+
+          def build_map
+            classes = {}
+            @repository.classes_index.each do |klass|
+              id = @id_generator.class_id(klass)
+              classes[id] = serialize(klass, id)
+            end
+            classes
+          end
+
+          private
+
+          def serialize(klass, id) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+            class_associations = find_class_associations(klass)
+            sorted_associations = sort_associations(class_associations, klass)
+
+            {
+              id: id,
+              xmiId: klass.xmi_id,
+              name: klass.name,
+              qualifiedName: qualified_name_for(klass),
+              type: class_type_for(klass),
+              package: package_id_for_class(klass),
+              stereotypes: normalize_stereotypes(
+                klass.respond_to?(:stereotype) ? klass.stereotype : nil,
+              ),
+              definition: format_definition(klass.definition),
+              attributes: (klass.attributes || []).sort_by { |a| a.name || "" }
+                .map { |attr| @id_generator.attribute_id(attr, klass) },
+              operations: serialize_class_operations(klass),
+              associations: sorted_associations,
+              generalizations: @inheritance_resolver.find_generalizations(klass),
+              specializations: @inheritance_resolver.find_specializations(klass),
+              isAbstract: klass.respond_to?(:is_abstract) ? klass.is_abstract : false,
+              literals: serialize_literals(klass),
+              inheritedAttributes: @inheritance_resolver.compute_inherited_attributes(klass),
+              inheritedAssociations: @inheritance_resolver.compute_inherited_associations(klass),
+            }
+          end
+
+          def find_class_associations(klass)
+            associations = @repository.associations_of(klass)
+            associations.map { |assoc| @id_generator.association_id(assoc) }
+          rescue StandardError
+            []
+          end
+
+          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
+              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
+            end
+          end
+
+          def serialize_class_operations(klass)
+            return [] unless klass.respond_to?(:operations) && klass.operations
+
+            klass.operations.map { |op| @id_generator.operation_id(op, klass) }
+          end
+
+          def serialize_literals(klass)
+            return [] unless klass.is_a?(Lutaml::Uml::Enum) && klass.owned_literal
+
+            klass.owned_literal.map do |literal|
+              { name: literal.name,
+                definition: format_definition(literal.definition) }
+            end
+          rescue StandardError
+            []
+          end
+
+          def package_id_for_class(klass)
+            ns = klass.respond_to?(:namespace) ? klass.namespace : nil
+            return nil unless ns.is_a?(Lutaml::Uml::Package)
+
+            @id_generator.package_id(ns)
+          end
+
+          def format_definition(definition)
+            return nil if definition.nil? || definition.empty?
+
+            formatted = definition.strip
+            if @options[:max_definition_length] &&
+                formatted.length > @options[:max_definition_length]
+              formatted = "#{formatted[0...@options[:max_definition_length]]}..."
+            end
+            if @options[:format_definitions]
+              formatted = formatted.gsub(%r{(https?://[^\s]+)}, '[\1](\1)')
+            end
+            formatted
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    module StaticSite
+      module Serializers
+        class DiagramSerializer
+          def initialize(repository, id_generator, options)
+            @repository = repository
+            @id_generator = id_generator
+            @options = options
+          end
+
+          def build_map
+            diagrams = {}
+            @repository.diagrams_index.each do |diagram|
+              id = @id_generator.diagram_id(diagram)
+              diagrams[id] = serialize(diagram, id)
+            end
+            diagrams
+          rescue StandardError
+            {}
+          end
+
+          private
+
+          def serialize(diagram, id)
+            {
+              id: id,
+              xmiId: diagram.xmi_id,
+              name: diagram.name,
+              type: diagram.diagram_type,
+              package: find_diagram_package(diagram),
+            }
+          end
+
+          def find_diagram_package(diagram)
+            @repository.packages_index.each do |pkg|
+              diagrams = package_diagrams(pkg)
+              if diagrams.any? { |d| d.xmi_id == diagram.xmi_id }
+                return @id_generator.package_id(pkg)
+              end
+            end
+            nil
+          rescue StandardError
+            nil
+          end
+
+          def package_diagrams(package)
+            return [] unless @options[:include_diagrams]
+
+            package.diagrams || []
+          rescue StandardError
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require_relative "../../../uml/model_helpers"
+require_relative "../../class_lookup_index"
+
+module Lutaml
+  module UmlRepository
+    module StaticSite
+      module Serializers
+        class InheritanceResolver
+          include Lutaml::Uml::ModelHelpers
+
+          def initialize(repository, id_generator, options, generalization_map)
+            @repository = repository
+            @id_generator = id_generator
+            @options = options
+            @generalization_map = generalization_map
+          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
+
+            parent = @repository.supertype_of(klass)
+            return [] if parent && parent.xmi_id == klass.xmi_id
+
+            parent ? [@id_generator.class_id(parent)] : []
+          rescue StandardError => e
+            warn "Error finding generalizations for #{klass.name}: #{e.message}"
+            []
+          end
+
+          def find_specializations(klass)
+            children = @repository.subtypes_of(klass)
+            children.reject { |child| child.xmi_id == klass.xmi_id }
+              .map { |child| @id_generator.class_id(child) }
+          rescue StandardError
+            []
+          end
+
+          def compute_inherited_attributes(klass, visited = Set.new)
+            unless klass.respond_to?(:generalization) && klass.generalization
+              return []
+            end
+            return [] if visited.include?(klass.xmi_id)
+
+            visited.add(klass.xmi_id)
+            inherited = []
+            current_gen = klass.generalization
+            parent_order = 0
+
+            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)
+
+              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 << {
+                    attributeId: attr_id,
+                    attribute: serialize_attribute(attr, parent_class, attr_id),
+                    inheritedFrom: @id_generator.class_id(parent_class),
+                    inheritedFromName: parent_class.name,
+                    parentOrder: parent_order,
+                  }
+                end
+              end
+
+              parent_order += 1
+              current_gen = current_gen.general if current_gen.respond_to?(:general)
+            end
+
+            inherited
+          rescue StandardError => e
+            warn "Error computing inherited attributes: #{e.message}"
+            []
+          end
+
+          def compute_inherited_associations(klass, visited = Set.new)
+            unless klass.respond_to?(:generalization) && klass.generalization
+              return []
+            end
+            return [] if visited.include?(klass.xmi_id)
+
+            visited.add(klass.xmi_id)
+            inherited = []
+            current_gen = klass.generalization
+            parent_order = 0
+
+            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)
+
+              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
+
+              assoc_with_roles.sort_by { |a| a[:role] }.each do |item|
+                inherited << {
+                  associationId: item[:id],
+                  inheritedFrom: @id_generator.class_id(parent_class),
+                  inheritedFromName: parent_class.name,
+                  parentOrder: parent_order,
+                  localRole: item[:role],
+                }
+              end
+
+              parent_order += 1
+              current_gen = current_gen.general if current_gen.respond_to?(:general)
+            end
+
+            inherited
+          rescue StandardError => e
+            warn "Error computing inherited associations: #{e.message}"
+            []
+          end
+
+          def serialize_generalization(klass, visited = Set.new)
+            unless klass.respond_to?(:generalization) && klass.generalization
+              return nil
+            end
+            return nil if visited.include?(klass.xmi_id)
+
+            visited.add(klass.xmi_id)
+            gen = klass.generalization
+
+            {
+              generalId: gen.general_id,
+              generalName: gen.general_name,
+              generalUpperKlass: gen.respond_to?(:general_upper_klass) ? gen.general_upper_klass : nil,
+              hasGeneral: gen.respond_to?(:has_general) ? gen.has_general : false,
+              name: gen.name,
+              type: gen.type,
+              definition: format_definition(gen.definition),
+              stereotype: gen.respond_to?(:stereotype) ? gen.stereotype : nil,
+              ownedProps: serialize_general_attrs(gen, :owned_props),
+              assocProps: serialize_general_attrs(gen, :assoc_props),
+              inheritedProps: serialize_general_attrs(gen, :inherited_props),
+              inheritedAssocProps: serialize_general_attrs(gen,
+                                                           :inherited_assoc_props),
+            }
+          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.respond_to?(:upper_klass) ? attr.upper_klass : nil,
+              nameNs: attr.respond_to?(:name_ns) ? attr.name_ns : nil,
+              typeNs: attr.respond_to?(:type_ns) ? attr.type_ns : nil,
+            }
+          end
+
+          private
+
+          def class_lookup
+            @class_lookup ||= ClassLookupIndex.new(@repository.classes_index)
+          end
+
+          def find_class_associations(klass)
+            associations = @repository.associations_of(klass)
+            associations.map { |assoc| @id_generator.association_id(assoc) }
+          rescue StandardError
+            []
+          end
+
+          def serialize_attribute(attribute, owner, id)
+            {
+              id: id,
+              name: attribute.name,
+              type: attribute.type,
+              visibility: attribute.visibility,
+              owner: @id_generator.class_id(owner),
+              ownerName: owner.name,
+              cardinality: serialize_cardinality(attribute.cardinality),
+              definition: format_definition(attribute.definition),
+              stereotypes: normalize_stereotypes(
+                attribute.respond_to?(:stereotype) ? attribute.stereotype : nil,
+              ),
+              isStatic: attribute.respond_to?(:is_static) ? attribute.is_static : false,
+              isReadOnly: attribute.respond_to?(:is_read_only) ? attribute.is_read_only : false,
+              defaultValue: attribute.respond_to?(:default) ? attribute.default : nil,
+            }
+          end
+
+          def serialize_general_attrs(gen, method)
+            return [] unless gen.respond_to?(method)
+
+            (gen.send(method) || []).map do |attr|
+              serialize_general_attribute(attr)
+            end
+          end
+
+          def serialize_cardinality(cardinality)
+            return nil unless cardinality
+
+            {
+              min: cardinality.min,
+              max: cardinality.max,
+            }
+          end
+
+          def format_definition(definition)
+            return nil if definition.nil? || definition.empty?
+
+            formatted = definition.strip
+            if @options[:max_definition_length] &&
+                formatted.length > @options[:max_definition_length]
+              formatted = "#{formatted[0...@options[:max_definition_length]]}..."
+            end
+            if @options[:format_definitions]
+              formatted = formatted.gsub(%r{(https?://[^\s]+)}, '[\1](\1)')
+            end
+            formatted
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    module StaticSite
+      module Serializers
+        class MetadataBuilder
+          def initialize(repository)
+            @repository = repository
+          end
+
+          def build
+            {
+              generated: Time.now.utc.iso8601,
+              generator: "LutaML Static Site Generator",
+              version: "1.0",
+              statistics: build_statistics,
+            }
+          end
+
+          private
+
+          def build_statistics
+            {
+              packages: @repository.packages_index.size,
+              classes: @repository.classes_index.size,
+              associations: @repository.associations_index.size,
+              attributes: count_total_attributes,
+              operations: count_total_operations,
+            }
+          end
+
+          def count_total_attributes
+            @repository.classes_index.sum do |klass|
+              klass.attributes&.size || 0
+            end
+          end
+
+          def count_total_operations
+            @repository.classes_index.sum do |klass|
+              (klass.respond_to?(:operations) ? klass.operations&.size : 0) || 0
+            end
+          end
+        end
+      end
+    end
+  end
+end