lutaml 0.10.18 → 0.11.2

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

@@ -1,434 +0,0 @@
-# frozen_string_literal: true
-
-require "liquid"
-require "json"
-require "fileutils"
-
-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
-      # and using external configuration instead of hardcoded values.
-      #
-      # @example Single-file generation
-      #   config = Configuration.load
-      #   generator = Generator.new(repository, config: config,
-      #     mode: :single_file)
-      #   generator.generate
-      #
-      # @example With dependency injection
-      #   generator = Generator.new(repository,
-      #     config: custom_config,
-      #     id_generator: custom_id_gen,
-      #     data_transformer: custom_transformer
-      #   )
-      class Generator
-        attr_reader :repository, :config, :options
-
-        # Initialize generator with dependency injection
-        #
-        # @param repository [UmlRepository] The repository to generate site for
-        # @param options [Hash] Generation options
-        # @option options [Configuration] :config Configuration instance
-        # (default: auto-loaded)
-        # @option options [IDGenerator] :id_generator ID generator instance
-        # @option options [DataTransformer] :data_transformer Data
-        # transformer instance
-        # @option options [SearchIndexBuilder] :search_builder Search index
-        # builder instance
-        # @option options [Symbol] :mode Output mode
-        # (:single_file or :multi_file)
-        # @option options [String] :output Output path
-        # @option options [Boolean] :minify Minify output (overrides config)
-        def initialize(repository, options = {}) # rubocop:disable Metrics/MethodLength
-          @repository = repository
-          @config = options[:config] ||
-            Configuration.load(options[:config_path])
-          @options = build_options(options)
-
-          # Dependency injection for testability
-          @id_generator = options[:id_generator] || IDGenerator.new
-          @data_transformer = options[:data_transformer] ||
-            create_data_transformer
-          @search_builder = options[:search_builder] ||
-            create_search_builder
-
-          @liquid = setup_liquid
-        end
-
-        # Generate the static site
-        #
-        # @return [String] Path to generated output
-        def generate
-          case @options[:mode]
-          when :single_file
-            generate_single_file
-          when :multi_file
-            generate_multi_file
-          else
-            raise ArgumentError,
-                  "Invalid mode: #{@options[:mode]}. " \
-                  "Use :single_file or :multi_file"
-          end
-        end
-
-        private
-
-        # Build final options merging user options with configuration
-        def build_options(user_options) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          # Priority: user_options > config > defaults
-          defaults = {
-            mode: :single_file,
-            output: determine_default_output,
-          }
-
-          config_options = {
-            title: @config.ui&.title,
-            description: @config.ui&.description,
-            minify: if user_options[:mode] == :single_file
-                      @config.output&.single_file&.minify
-                    else
-                      @config.output&.multi_file&.minify
-                    end,
-            template_path: parse_template_path || default_template_path,
-          }.compact
-
-          defaults.merge(config_options).merge(user_options)
-        end
-
-        def parse_template_path # rubocop:disable Metrics/MethodLength
-          return nil unless @config.templates
-
-          templates_hash = case @config.templates
-                           when Hash
-                             @config.templates
-                           when String
-                             begin
-                               YAML.safe_load(@config.templates)
-                             rescue StandardError
-                               nil
-                             end
-                           end
-
-          templates_hash&.dig("base_path")
-        end
-
-        def determine_default_output # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-          if @config.output&.single_file&.enabled
-            @config.output.single_file.default_filename || "browser.html"
-          elsif @config.output&.multi_file&.enabled
-            @config.output.multi_file.default_directory || "dist"
-          else
-            "browser.html"
-          end
-        end
-
-        def create_data_transformer
-          DataTransformer.new(@repository, transformer_options)
-        end
-
-        def create_search_builder
-          SearchIndexBuilder.new(@repository, search_options)
-        end
-
-        def transformer_options
-          config_opts = @config.transformation_options || {}
-          {
-            include_diagrams: config_opts["include_diagrams"] != false,
-            format_definitions: config_opts["format_definitions"] != false,
-            max_definition_length: config_opts["max_definition_length"],
-          }.merge(@options.slice(:include_diagrams, :format_definitions,
-                                 :render_diagrams))
-        end
-
-        def search_options
-          {
-            # Pass search configuration to builder
-            fields: @config.search&.fields,
-            document_types: @config.search&.document_types,
-            stop_words: @config.search&.stop_words,
-          }
-        end
-
-        def default_template_path
-          # From lib/lutaml/uml_repository/static_site/generator.rb
-          # Up 4 levels: static_site/ → uml_repository/ → lutaml/ → lib/ →
-          # (root)
-          File.expand_path("../../../../templates/static_site", __dir__)
-        end
-
-        def setup_liquid
-          @liquid_environment = Liquid::Environment.new
-          @liquid_environment.file_system = TemplateFileSystem.new(@options[:template_path])
-          @liquid_environment.error_mode = :lax
-        end
-
-        # Generate single-file SPA
-        def generate_single_file # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          puts "Generating single-file SPA..."
-
-          # Transform data
-          data = @data_transformer.transform
-          search_index = @search_builder.build
-
-          # Build CSS and JS
-          css_content = build_css
-          js_content = build_js
-
-          # Build initial context
-          context = build_liquid_context(
-            data.to_json, search_index.to_json, :single_file
-          )
-          context["styles"] = css_content
-          context["scripts"] = js_content
-
-          # Render components with context (call the lambda)
-          component_renderer = render_components
-          rendered_components = component_renderer.call(context)
-          context.merge!(rendered_components)
-
-          # Render template
-          template_path = File.join(@options[:template_path],
-                                    "single_file.liquid")
-          template_content = File.read(template_path)
-          template = Liquid::Template.parse(template_content)
-
-          html = template.render(context)
-
-          # Check for rendering errors
-          if html.nil? || html.empty?
-            errors = if template.errors.any?
-                       template.errors.join(", ")
-                     else
-                       "No specific errors, but output is empty"
-                     end
-            raise "Template rendering failed. Errors: #{errors}"
-          end
-
-          # Minify if requested
-          html = minify_html(html) if @options[:minify]
-
-          # Write output
-          File.write(@options[:output], html)
-          puts "✓ Generated: #{@options[:output]} " \
-               "(#{File.size(@options[:output]) / 1024}KB)"
-
-          @options[:output]
-        end
-
-        def render_components # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          # Set up Liquid file system for recursive includes
-          temp_file_system = TemplateFileSystem.new(@options[:template_path])
-
-          component_names = ["header", "sidebar", "content", "package_details",
-                             "class_details"]
-          components = {}
-
-          # We need the context to render components, so we'll return a lambda
-          # that will be called with the context
-          lambda do |context|
-            component_names.each do |name|
-              component_path = File.join(@options[:template_path],
-                                         "components", "#{name}.liquid")
-              if File.exist?(component_path)
-                component_template = Liquid::Template.parse(File.read(component_path))
-                component_template.registers[:file_system] = temp_file_system
-                components[name] = component_template.render(context)
-              else
-                components[name] = "<!-- Component #{name} not found -->"
-              end
-            end
-            components
-          end
-        end
-
-        # Generate multi-file static site
-        def generate_multi_file # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          puts "Generating multi-file static site..."
-
-          output_dir = @options[:output]
-          FileUtils.mkdir_p(output_dir)
-          FileUtils.mkdir_p(File.join(output_dir, "data"))
-          FileUtils.mkdir_p(File.join(output_dir, "assets"))
-
-          # Transform data
-          data = @data_transformer.transform
-          search_index = @search_builder.build
-
-          # Write data files
-          write_data_file(File.join(output_dir, "data", "model.json"), data)
-          write_data_file(File.join(output_dir, "data", "search.json"),
-                          search_index)
-
-          # Build context (without embedded data)
-          context = build_liquid_context(nil, nil, :multi_file)
-
-          # Render and write index.html
-          template_content = File.read(File.join(@options[:template_path],
-                                                 "multi_file.liquid"))
-          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)
-
-          # Copy/generate assets
-          generate_assets(output_dir)
-
-          puts "✓ Generated multi-file site in: #{output_dir}"
-          output_dir
-        end
-
-        def build_liquid_context(data, search_index, mode) # rubocop:disable Metrics/MethodLength
-          config_hash = {
-            "mode" => mode.to_s,
-            "title" => @options[:title],
-            "description" => @options[:description],
-            "theme" => @options[:theme],
-            "apiMode" => false, # Static mode by default
-          }
-
-          images_dir = File.join(@options[:template_path], "assets", "images")
-          lutaml_icon = read_svg_asset(images_dir, "lutaml-icon.svg")
-          lutaml_full_logo = read_svg_asset(images_dir, "lutaml-full.svg")
-
-          {
-            "config" => JSON.generate(config_hash),
-            "data" => data,
-            "searchIndex" => search_index,
-            "lutamlIcon" => lutaml_icon,
-            "lutamlFullLogo" => lutaml_full_logo,
-            "buildInfo" => {
-              "timestamp" => Time.now.utc.iso8601,
-              "generator" => "LutaML Static Site Generator v1.0",
-            },
-          }
-        end
-
-        def write_data_file(path, data)
-          json = JSON.pretty_generate(data)
-          File.write(path, json)
-          puts "  ✓ #{File.basename(path)} (#{File.size(path) / 1024}KB)"
-        end
-
-        def read_svg_asset(images_dir, filename)
-          path = File.join(images_dir, filename)
-          return "" unless File.exist?(path)
-
-          File.read(path).strip
-        end
-
-        def generate_assets(output_dir) # rubocop:disable Metrics/MethodLength
-          assets_dir = File.join(output_dir, "assets")
-
-          # Generate CSS
-          css_content = build_css
-          css_path = File.join(assets_dir, "styles.css")
-          File.write(css_path, css_content)
-          puts "  ✓ styles.css (#{File.size(css_path) / 1024}KB)"
-
-          # Generate JS
-          js_content = build_js
-          js_path = File.join(assets_dir, "app.js")
-          File.write(js_path, js_content)
-          puts "  ✓ app.js (#{File.size(js_path) / 1024}KB)"
-
-          # Copy image assets
-          copy_image_assets(assets_dir)
-        end
-
-        def copy_image_assets(assets_dir)
-          images_src = File.join(@options[:template_path], "assets", "images")
-          return unless Dir.exist?(images_src)
-
-          images_dest = File.join(assets_dir, "images")
-          FileUtils.mkdir_p(images_dest)
-          Dir.glob(File.join(images_src, "*")).each do |src_file|
-            next if File.directory?(src_file)
-
-            dest_file = File.join(images_dest, File.basename(src_file))
-            FileUtils.cp(src_file, dest_file)
-          end
-        end
-
-        CSS_FILES = %w[
-          00-variables.css 01-reset.css 02-base.css 03-layout.css
-          04-components.css 05-utilities.css 06-diagrams.css
-        ].freeze
-
-        JS_FILES = %w[
-          core/utils.js core/state.js core/router.js
-          search/lunr-custom.js ui/sidebar.js ui/details.js
-          ui/search.js app.js
-        ].freeze
-
-        def build_css
-          concatenate_assets("styles", CSS_FILES, :minify_css)
-        end
-
-        def build_js
-          concatenate_assets("scripts", JS_FILES, :minify_js)
-        end
-
-        def concatenate_assets(subdir, files, minifier)
-          content = files.map do |file|
-            path = File.join(@options[:template_path], "assets", subdir, file)
-            File.exist?(path) ? File.read(path) : ""
-          end.join("\n\n")
-
-          @options[:minify] ? public_send(minifier, content) : content
-        end
-
-        def minify_html(html)
-          # Basic HTML minification
-          html.gsub(/\s+/, " ")
-            .gsub(/>\s+</, "><")
-            .strip
-        end
-
-        def minify_css(css)
-          # Basic CSS minification
-          css.gsub(/\s+/, " ")
-            .gsub(/\s*{\s*/, "{")
-            .gsub(/\s*}\s*/, "}")
-            .gsub(/\s*:\s*/, ":")
-            .gsub(/\s*;\s*/, ";")
-            .strip
-        end
-
-        def minify_js(js)
-          # Basic JS minification (remove comments and extra whitespace)
-          js.gsub(%r{//.*$}, "")       # Remove single-line comments
-            .gsub(%r{/\*.*?\*/}m, "")  # Remove multi-line comments
-            .gsub(/\s+/, " ")          # Collapse whitespace
-            .strip
-        end
-      end
-    end
-  end
-end

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

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "digest"
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      # Generates stable, short IDs for entities in the JSON data model.
-      #
-      # Uses MD5 hash of XMI IDs to create consistent, collision-resistant IDs
-      # that remain stable across multiple generations.
-      #
-      # @example
-      #   generator = IDGenerator.new
-      #   pkg_id = generator.package_id(package)  # => "pkg_a1b2c3d4"
-      #   cls_id = generator.class_id(klass)      # => "cls_e5f6g7h8"
-      class IDGenerator
-        def initialize
-          @cache = {}
-        end
-
-        # Generate ID for a package
-        #
-        # @param package [Lutaml::Uml::Package] Package object
-        # @return [String] Stable package ID (e.g., "pkg_a1b2c3d4")
-        def package_id(package)
-          # Use XMI ID for uniqueness - each package has unique XMI ID
-          # even if names are identical in different hierarchies
-          cache_key = [:package, package.xmi_id]
-          @cache[cache_key] ||= generate_id("pkg", package.xmi_id)
-        end
-
-        # Generate ID for a class
-        #
-        # @param klass [Lutaml::Uml::TopElement] Class object
-        # @return [String] Stable class ID (e.g., "cls_a1b2c3d4")
-        def class_id(klass)
-          cache_key = [:class, klass.xmi_id]
-          @cache[cache_key] ||= generate_id("cls", klass.xmi_id)
-        end
-
-        # Generate ID for an attribute
-        #
-        # @param attribute [Object] Attribute object
-        # @param owner [Object] Owner class
-        # @return [String] Stable attribute ID (e.g., "attr_a1b2c3d4")
-        def attribute_id(attribute, owner)
-          # Use combination of owner ID and attribute name for uniqueness
-          composite_key = "#{owner.xmi_id}::#{attribute.name}"
-          cache_key = [:attribute, composite_key]
-          @cache[cache_key] ||= generate_id("attr", composite_key)
-        end
-
-        # Generate ID for an association
-        #
-        # @param association [Lutaml::Uml::Association] Association object
-        # @return [String] Stable association ID (e.g., "assoc_a1b2c3d4")
-        def association_id(association)
-          cache_key = [:association, association.xmi_id]
-          @cache[cache_key] ||= generate_id("assoc", association.xmi_id)
-        end
-
-        # Generate ID for an operation
-        #
-        # @param operation [Object] Operation object
-        # @param owner [Object] Owner class
-        # @return [String] Stable operation ID (e.g., "op_a1b2c3d4")
-        def operation_id(operation, owner)
-          composite_key = "#{owner.xmi_id}::#{operation.name}"
-          cache_key = [:operation, composite_key]
-          @cache[cache_key] ||= generate_id("op", composite_key)
-        end
-
-        # Generate ID for a diagram
-        #
-        # @param diagram [Object] Diagram object
-        # @return [String] Stable diagram ID (e.g., "diag_a1b2c3d4")
-        def diagram_id(diagram)
-          cache_key = [:diagram, diagram.xmi_id]
-          @cache[cache_key] ||= generate_id("diag", diagram.xmi_id)
-        end
-
-        # Generate ID for a search document
-        #
-        # @param type [String] Document type (class, attribute, etc.)
-        # @param entity_id [String] Entity XMI ID
-        # @return [String] Stable document ID (e.g., "doc_class_a1b2c3d4")
-        def document_id(type, entity_id)
-          cache_key = [:document, type, entity_id]
-          @cache[cache_key] ||= generate_id("doc_#{type}", entity_id)
-        end
-
-        # Clear the cache (useful for testing)
-        #
-        # @return [void]
-        def clear_cache
-          @cache.clear
-        end
-
-        private
-
-        # Generate a stable ID from a prefix and key
-        #
-        # @param prefix [String] ID prefix (e.g., "pkg", "cls")
-        # @param key [String] Key to hash (typically XMI ID)
-        # @return [String] Generated ID
-        def generate_id(prefix, key)
-          # Use first 8 characters of MD5 hash for short, stable IDs
-          hash = Digest::MD5.hexdigest(key.to_s)[0..7]
-          "#{prefix}_#{hash}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Models
-        class SpaAssociation < SpaBase
-          attribute :id, :string
-          attribute :xmi_id, :string
-          attribute :name, :string
-          attribute :type, :string
-          attribute :definition, :string
-          attribute :source, SpaAssociationEnd
-          attribute :target, SpaAssociationEnd
-
-          json do
-            map "id", to: :id
-            map "xmiId", to: :xmi_id
-            map "name", to: :name
-            map "type", to: :type
-            map "definition", to: :definition
-            map "source", to: :source
-            map "target", to: :target
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Models
-        class SpaAssociationEnd < SpaBase
-          attribute :klass, :string
-          attribute :class_name, :string
-          attribute :role, :string
-          attribute :cardinality, SpaCardinality
-          attribute :aggregation, :string
-
-          json do
-            map "class", to: :klass
-            map "className", to: :class_name
-            map "role", to: :role
-            map "cardinality", to: :cardinality
-            map "aggregation", to: :aggregation
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Models
-        class SpaAttribute < SpaBase
-          attribute :id, :string
-          attribute :name, :string
-          attribute :type, :string
-          attribute :visibility, :string
-          attribute :owner, :string
-          attribute :owner_name, :string
-          attribute :cardinality, SpaCardinality
-          attribute :definition, :string
-          attribute :stereotypes, :string, collection: true, default: -> { [] }
-          attribute :is_static, :boolean, default: false
-          attribute :is_read_only, :boolean, default: false
-          attribute :default_value, :string
-
-          json do
-            map "id", to: :id
-            map "name", to: :name
-            map "type", to: :type
-            map "visibility", to: :visibility
-            map "owner", to: :owner
-            map "ownerName", to: :owner_name
-            map "cardinality", to: :cardinality
-            map "definition", to: :definition
-            map "stereotypes", to: :stereotypes
-            map "isStatic", to: :is_static
-            map "isReadOnly", to: :is_read_only
-            map "defaultValue", to: :default_value
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Models
-        class SpaBase < Lutaml::Model::Serializable
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      module Models
-        class SpaCardinality < SpaBase
-          attribute :min, :string
-          attribute :max, :string
-
-          json do
-            map "min", to: :min
-            map "max", to: :max
-          end
-        end
-      end
-    end
-  end
-end