lutaml 0.10.19 → 0.11.2

data/lib/lutaml/uml_repository/static_site/models/spa_search_index.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Models
-        class SpaSearchIndex < SpaBase
-          attribute :version, :string, default: "1.0.0"
-          attribute :fields, :hash, collection: true, initialize_empty: true
-          attribute :ref, :string, default: "id"
-          attribute :document_store, SpaSearchEntry, collection: true,
-                                                     initialize_empty: true
-          attribute :pipeline, :string, collection: true,
-                                        default: -> {
-                                          %w[stemmer stopWordFilter]
-                                        }
-
-          json do
-            map "version", to: :version, render_default: true
-            map "fields", to: :fields, render_empty: true
-            map "ref", to: :ref, render_default: true
-            map "documentStore", to: :document_store, render_empty: true
-            map "pipeline", to: :pipeline, render_default: true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/static_site/models/spa_statistics.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Models
-        class SpaStatistics < SpaBase
-          attribute :packages, :integer, default: 0
-          attribute :classes, :integer, default: 0
-          attribute :associations, :integer, default: 0
-          attribute :attributes, :integer, default: 0
-          attribute :operations, :integer, default: 0
-
-          json do
-            map "packages", to: :packages, render_default: true
-            map "classes", to: :classes, render_default: true
-            map "associations", to: :associations, render_default: true
-            map "attributes", to: :attributes, render_default: true
-            map "operations", to: :operations, render_default: true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/static_site/models/spa_tree_class_ref.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Models
-        class SpaTreeClassRef < SpaBase
-          attribute :id, :string
-          attribute :name, :string
-          attribute :stereotypes, :string, collection: true,
-                                           initialize_empty: true
-
-          json do
-            map "id", to: :id
-            map "name", to: :name
-            map "stereotypes", to: :stereotypes, render_empty: true
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Models
-        autoload :SpaBase, "lutaml/uml_repository/static_site/models/spa_base"
-        autoload :SpaAssociation,
-                 "lutaml/uml_repository/static_site/models/spa_association"
-        autoload :SpaAssociationEnd,
-                 "lutaml/uml_repository/static_site/models/spa_association_end"
-        autoload :SpaAttribute,
-                 "lutaml/uml_repository/static_site/models/spa_attribute"
-        autoload :SpaCardinality,
-                 "lutaml/uml_repository/static_site/models/spa_cardinality"
-        autoload :SpaClass, "lutaml/uml_repository/static_site/models/spa_class"
-        autoload :SpaDiagram,
-                 "lutaml/uml_repository/static_site/models/spa_diagram"
-        autoload :SpaDocument,
-                 "lutaml/uml_repository/static_site/models/spa_document"
-        autoload :SpaInheritedAssociation,
-                 "lutaml/uml_repository/static_site/models/spa_inherited_association"
-        autoload :SpaInheritedAttribute,
-                 "lutaml/uml_repository/static_site/models/spa_inherited_attribute"
-        autoload :SpaLiteral,
-                 "lutaml/uml_repository/static_site/models/spa_literal"
-        autoload :SpaMetadata,
-                 "lutaml/uml_repository/static_site/models/spa_metadata"
-        autoload :SpaOperation,
-                 "lutaml/uml_repository/static_site/models/spa_operation"
-        autoload :SpaPackage,
-                 "lutaml/uml_repository/static_site/models/spa_package"
-        autoload :SpaPackageTreeNode,
-                 "lutaml/uml_repository/static_site/models/spa_package_tree_node"
-        autoload :SpaParameter,
-                 "lutaml/uml_repository/static_site/models/spa_parameter"
-        autoload :SpaSearchEntry,
-                 "lutaml/uml_repository/static_site/models/spa_search_entry"
-        autoload :SpaSearchIndex,
-                 "lutaml/uml_repository/static_site/models/spa_search_index"
-        autoload :SpaStatistics,
-                 "lutaml/uml_repository/static_site/models/spa_statistics"
-        autoload :SpaTreeClassRef,
-                 "lutaml/uml_repository/static_site/models/spa_tree_class_ref"
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/static_site/output/multi_file_strategy.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "fileutils"
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Output
-        # Generates a multi-file static site: separate JSON data files
-        # and an index.html that loads them.
-        class MultiFileStrategy < Strategy
-          def render(spa_document, search_index)
-            output_dir = output_path
-            FileUtils.mkdir_p(output_dir)
-            FileUtils.mkdir_p(File.join(output_dir, "data"))
-
-            write_json(File.join(output_dir, "data", "model.json"),
-                       spa_document)
-            write_json(File.join(output_dir, "data", "search.json"),
-                       search_index)
-
-            html = build_index_html
-            File.write(File.join(output_dir, "index.html"), html)
-
-            output_dir
-          end
-
-          private
-
-          def write_json(path, data)
-            json = JSON.pretty_generate(JSON.parse(data.to_json))
-            File.write(path, json)
-          end
-
-          def build_index_html
-            title = config.ui&.title || "UML Browser"
-            description = config.ui&.description || "UML Model Documentation"
-
-            <<~HTML
-              <!DOCTYPE html>
-              <html lang="en">
-              <head>
-                <meta charset="UTF-8">
-                <meta name="viewport" content="width=device-width, initial-scale=1.0">
-                <title>#{title}</title>
-                <meta name="description" content="#{description}">
-                <meta name="generator" content="LutaML Static Site Generator">
-
-                <link rel="preconnect" href="https://fonts.googleapis.com">
-                <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-                <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
-              </head>
-              <body>
-                <div id="app"></div>
-
-                <script>
-                window.__SPA_DATA_URL__ = 'data/model.json';
-                window.__SPA_SEARCH_URL__ = 'data/search.json';
-                </script>
-              </body>
-              </html>
-            HTML
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/static_site/output/strategy.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Output
-        # Base class for output strategies (Strategy Pattern).
-        #
-        # Subclasses implement #render to produce HTML output from
-        # a SpaDocument and SpaSearchIndex.
-        #
-        # @abstract Subclass and implement {#render}
-        class Strategy
-          def initialize(output_path, config:)
-            @output_path = output_path
-            @config = config
-          end
-
-          # Render output from the given document and search index.
-          #
-          # @param spa_document [Models::SpaDocument]
-          # @param search_index [Models::SpaSearchIndex]
-          # @return [String] Path to generated output
-          def render(_spa_document, _search_index)
-            raise NotImplementedError,
-                  "#{self.class} must implement #render"
-          end
-
-          private
-
-          attr_reader :output_path, :config
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/static_site/output/vue_inlined_strategy.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "fileutils"
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Output
-        # Generates a single self-contained HTML file with embedded
-        # pre-built Vue IIFE, CSS, and JSON data.
-        #
-        # Matches the pattern used by lutaml-xsd and lutaml-jsonschema:
-        # data in window.__SPA_DATA__, Vue app reads it and renders.
-        class VueInlinedStrategy < Strategy
-          FRONTEND_DIST = File.expand_path(
-            "../../../../../frontend/dist", __dir__
-          )
-
-          def render(spa_document, search_index)
-            FileUtils.mkdir_p(File.dirname(output_path))
-
-            js = read_frontend_asset("app.iife.js")
-            css = read_frontend_asset("style.css")
-
-            data_json = build_data_json(spa_document, search_index)
-            html = build_html(data_json, js, css)
-
-            File.write(output_path, html)
-            output_path
-          end
-
-          private
-
-          def read_frontend_asset(filename)
-            path = File.join(FRONTEND_DIST, filename)
-            return File.read(path) if File.exist?(path)
-
-            raise <<~MSG
-              Frontend asset not found: #{path}
-              Run `cd frontend && npm install && npm run build` first.
-            MSG
-          end
-
-          def build_data_json(spa_document, search_index)
-            metadata_hash = JSON.parse(spa_document.metadata.to_json)
-
-            # Parse appearance JSON string back into the metadata
-            if metadata_hash["appearance"].is_a?(String) && !metadata_hash["appearance"].empty?
-              begin
-                metadata_hash["appearance"] =
-                  JSON.parse(metadata_hash["appearance"])
-              rescue StandardError
-                metadata_hash.delete("appearance")
-              end
-            else
-              metadata_hash.delete("appearance")
-            end
-
-            {
-              metadata: metadata_hash,
-              packageTree: spa_document.package_tree,
-              packages: spa_document.packages,
-              classes: spa_document.classes,
-              attributes: spa_document.attributes,
-              associations: spa_document.associations,
-              operations: spa_document.operations,
-              diagrams: spa_document.diagrams,
-              searchIndex: search_index,
-            }.to_json
-          end
-
-          def build_html(data_json, js, css)
-            meta = config&.metadata
-            title = config.ui&.title || meta&.title || "UML Browser"
-            description = config.ui&.description || meta&.description || "UML Model Documentation"
-
-            <<~HTML
-              <!DOCTYPE html>
-              <html lang="en">
-              <head>
-                <meta charset="UTF-8">
-                <meta name="viewport" content="width=device-width, initial-scale=1.0">
-                <title>#{title}</title>
-                <meta name="description" content="#{description}">
-                <meta name="generator" content="lutaml v#{Lutaml::VERSION}">
-
-                <link rel="preconnect" href="https://fonts.googleapis.com">
-                <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-                <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
-
-                <style>
-                #{css}
-                </style>
-              </head>
-              <body>
-                <div id="app"></div>
-
-                <script>
-                window.__SPA_DATA__ = #{data_json};
-                </script>
-                <script>
-                #{js}
-                </script>
-              </body>
-              </html>
-            HTML
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Output
-        autoload :Strategy, "lutaml/uml_repository/static_site/output/strategy"
-        autoload :VueInlinedStrategy,
-                 "lutaml/uml_repository/static_site/output/vue_inlined_strategy"
-        autoload :MultiFileStrategy,
-                 "lutaml/uml_repository/static_site/output/multi_file_strategy"
-      end
-    end
-  end
-end

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

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      class SearchIndexBuilder
-        include Lutaml::Uml::ModelHelpers
-
-        STOP_WORDS = %w[
-          the a an and or but in on at to for of with from by
-          is are was were be been being have has had
-          this that these those it its
-        ].freeze
-
-        attr_reader :repository, :id_generator, :options
-
-        def initialize(repository, options = {})
-          @repository = repository
-          @options = default_options.merge(options)
-          @id_generator = IdGenerator.new
-        end
-
-        def build
-          Models::SpaSearchIndex.new(
-            fields: field_definitions,
-            document_store: build_document_store,
-          )
-        end
-
-        private
-
-        def default_options
-          {
-            languages: ["en"],
-          }
-        end
-
-        def field_definitions
-          [
-            { name: "name", boost: 10 },
-            { name: "qualifiedName", boost: 5 },
-            { name: "type", boost: 3 },
-            { name: "package", boost: 2 },
-            { name: "content", boost: 1 },
-          ]
-        end
-
-        def build_document_store
-          documents = []
-          documents.concat(build_class_documents)
-          documents.concat(build_association_documents)
-          documents.concat(build_package_documents)
-          documents
-        end
-
-        def build_class_document(klass)
-          Models::SpaSearchEntry.new(
-            id: @id_generator.document_id("class", klass.xmi_id),
-            type: "class",
-            entity_type: class_type(klass),
-            entity_id: @id_generator.class_id(klass),
-            name: klass.name,
-            qualified_name: qualified_name_for(klass),
-            package: package_name(klass),
-            content: build_class_content(klass),
-            boost: 1.5,
-          )
-        end
-
-        def build_attribute_document(attribute, owner)
-          Models::SpaSearchEntry.new(
-            id: @id_generator.document_id("attribute",
-                                          "#{owner.xmi_id}::#{attribute.name}"),
-            type: "attribute",
-            entity_type: "Attribute",
-            entity_id: @id_generator.attribute_id(attribute, owner),
-            name: attribute.name,
-            qualified_name: "#{qualified_name_for(owner)}::#{attribute.name}",
-            package: package_name(owner),
-            content: build_attribute_content(attribute, owner),
-            boost: 1.0,
-          )
-        end
-
-        def build_association_document(association)
-          Models::SpaSearchEntry.new(
-            id: @id_generator.document_id("association", association.xmi_id),
-            type: "association",
-            entity_type: "Association",
-            entity_id: @id_generator.association_id(association),
-            name: association.name || "unnamed",
-            qualified_name: association.name || "unnamed",
-            package: "",
-            content: build_association_content(association),
-            boost: 0.8,
-          )
-        end
-
-        def build_package_document(package)
-          Models::SpaSearchEntry.new(
-            id: @id_generator.document_id("package", package.xmi_id),
-            type: "package",
-            entity_type: "Package",
-            entity_id: @id_generator.package_id(package),
-            name: package.name,
-            qualified_name: package_path_for(package),
-            package: parent_package_name(package),
-            content: build_package_content(package),
-            boost: 1.2,
-          )
-        end
-
-        def build_class_content(klass)
-          parts = [
-            klass.name,
-            qualified_name_for(klass),
-            class_type(klass),
-            Array(klass.stereotype).join(" "),
-            klass.definition,
-            collect_names(klass.attributes),
-            collect_names(klass.operations),
-          ].compact
-
-          normalize_content(parts.join(" "))
-        end
-
-        def build_attribute_content(attribute, owner)
-          parts = [
-            attribute.name,
-            attribute.type,
-            owner.name,
-            qualified_name_for(owner),
-            attribute.definition,
-            Array(attribute.stereotype).join(" "),
-          ].compact
-
-          normalize_content(parts.join(" "))
-        end
-
-        def build_association_content(association)
-          parts = [
-            association.name,
-            association.owner_end,
-            association.member_end,
-          ].compact
-
-          normalize_content(parts.join(" "))
-        end
-
-        def build_package_content(package)
-          parts = [
-            package.name,
-            package_path_for(package),
-            package.definition,
-            Array(package.stereotype).join(" "),
-          ].compact
-
-          normalize_content(parts.join(" "))
-        end
-
-        def normalize_content(text)
-          text = text.downcase
-          tokens = text.split(/[\s:]+/)
-          all_content = [text] + tokens
-          all_content = all_content.uniq.reject do |word|
-            STOP_WORDS.include?(word)
-          end
-          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
-
-        def package_name(klass)
-          return "" unless klass.namespace.is_a?(Lutaml::Uml::Package)
-
-          package_path_for(klass.namespace)
-        end
-
-        def parent_package_name(package)
-          return "" unless package.namespace.is_a?(Lutaml::Uml::Package)
-
-          package_path_for(package.namespace)
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Serializers
-        class AssociationSerializer < Base
-          def build_map
-            associations = {}
-
-            @repository.associations_index.each do |assoc|
-              id = @id_generator.association_id(assoc)
-              associations[id] = serialize(assoc, id)
-            end
-
-            associations
-          end
-
-          private
-
-          def serialize(association, id)
-            Models::SpaAssociation.new(
-              id: id,
-              xmi_id: association.xmi_id,
-              name: resolve_association_name(association),
-              type: "Association",
-              definition: format_definition(association.definition, @options),
-              source: build_association_source(association),
-              target: build_association_target(association),
-            )
-          end
-
-          def resolve_association_name(association)
-            name = association.name
-            return name if name && !name.empty?
-
-            role = association.owner_end_attribute_name
-            return role if role && !role.empty?
-
-            association.member_end_attribute_name
-          end
-
-          def build_association_source(association)
-            return nil unless association.owner_end
-
-            Models::SpaAssociationEnd.new(
-              klass: association.owner_end_xmi_id,
-              class_name: association.owner_end,
-              role: association.owner_end_attribute_name,
-              cardinality: Models::SpaCardinality.from_uml(association.owner_end_cardinality),
-              aggregation: association.owner_end_type,
-            )
-          end
-
-          def build_association_target(association)
-            return nil unless association.member_end
-
-            Models::SpaAssociationEnd.new(
-              klass: association.member_end_xmi_id,
-              class_name: association.member_end,
-              role: association.member_end_attribute_name,
-              cardinality: Models::SpaCardinality.from_uml(association.member_end_cardinality),
-              aggregation: association.member_end_type,
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Serializers
-        class AttributeSerializer < Base
-          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_attribute(attr, klass, id)
-              end
-            end
-            attributes
-          end
-        end
-      end
-    end
-  end
-end