lutaml 0.10.19 → 0.11.2

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

@@ -1,377 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-require "yaml"
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      # Configuration for Static Site Generator using external YAML.
-      #
-      # Follows the Dependency Inversion Principle by externalizing all
-      # configuration instead of hardcoding values. Uses lutaml-model for
-      # structured YAML parsing and validation.
-      #
-      # @example Load configuration
-      #   config = Configuration.load
-      #
-      # @example Load custom configuration
-      #   config = Configuration.load("my_config.yml")
-      class Configuration < Lutaml::Model::Serializable
-        # Output mode configuration
-        class OutputMode < Lutaml::Model::Serializable
-          attribute :enabled, :boolean, default: -> { true }
-          attribute :default_filename, :string
-          attribute :default_directory, :string
-          attribute :embed_data, :boolean
-          attribute :embed_styles, :boolean
-          attribute :embed_scripts, :boolean
-          attribute :data_directory, :string
-          attribute :assets_directory, :string
-          attribute :minify, :boolean, default: -> { false }
-
-          yaml do
-            map "enabled", to: :enabled
-            map "default_filename", to: :default_filename
-            map "default_directory", to: :default_directory
-            map "embed_data", to: :embed_data
-            map "embed_styles", to: :embed_styles
-            map "embed_scripts", to: :embed_scripts
-            map "data_directory", to: :data_directory
-            map "assets_directory", to: :assets_directory
-            map "minify", to: :minify
-          end
-        end
-
-        # Output configuration container
-        class OutputConfig < Lutaml::Model::Serializable
-          attribute :modes, :string # Will be parsed as hash
-
-          yaml do
-            map "modes", to: :modes
-          end
-
-          def single_file
-            @single_file ||= parse_mode_config(modes["single_file"]) if modes
-          end
-
-          def multi_file
-            @multi_file ||= parse_mode_config(modes["multi_file"]) if modes
-          end
-
-          private
-
-          def parse_mode_config(config_hash) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-            return nil unless config_hash
-
-            OutputMode.new.tap do |mode|
-              mode.enabled = config_hash["enabled"]
-              mode.default_filename = config_hash["default_filename"]
-              mode.default_directory = config_hash["default_directory"]
-              mode.embed_data = config_hash["embed_data"]
-              mode.embed_styles = config_hash["embed_styles"]
-              mode.embed_scripts = config_hash["embed_scripts"]
-              mode.data_directory = config_hash["data_directory"]
-              mode.assets_directory = config_hash["assets_directory"]
-              mode.minify = config_hash["minify"]
-            end
-          end
-        end
-
-        # Search field configuration
-        class SearchField < Lutaml::Model::Serializable
-          attribute :name, :string
-          attribute :boost, :integer, default: -> { 1 }
-          attribute :searchable, :boolean, default: -> { true }
-
-          yaml do
-            map "name", to: :name
-            map "boost", to: :boost
-            map "searchable", to: :searchable
-          end
-        end
-
-        # Document type configuration
-        class DocumentType < Lutaml::Model::Serializable
-          attribute :type, :string
-          attribute :boost, :float, default: -> { 1.0 }
-          attribute :enabled, :boolean, default: -> { true }
-
-          yaml do
-            map "type", to: :type
-            map "boost", to: :boost
-            map "enabled", to: :enabled
-          end
-        end
-
-        # Search configuration
-        class SearchConfig < Lutaml::Model::Serializable
-          attribute :enabled, :boolean, default: -> { true }
-          attribute :fields, SearchField, collection: true
-          attribute :document_types, DocumentType, collection: true
-          attribute :stop_words, :string, collection: true
-          attribute :pipeline, :string, collection: true
-
-          yaml do
-            map "enabled", to: :enabled
-            map "fields", to: :fields
-            map "document_types", to: :document_types
-            map "stop_words", to: :stop_words
-            map "pipeline", to: :pipeline
-          end
-        end
-
-        # UI configuration
-        class UIConfig < Lutaml::Model::Serializable
-          attribute :title, :string
-          attribute :description, :string
-          attribute :theme, :string # Will be parsed as hash
-          attribute :sidebar, :string # Will be parsed as hash
-          attribute :breadcrumb, :string  # Will be parsed as hash
-          attribute :statistics, :string  # Will be parsed as hash
-
-          yaml do
-            map "title", to: :title
-            map "description", to: :description
-            map "theme", to: :theme
-            map "sidebar", to: :sidebar
-            map "breadcrumb", to: :breadcrumb
-            map "statistics", to: :statistics
-          end
-        end
-
-        # Logo configuration for light/dark variants
-        class LogoVariant < Lutaml::Model::Serializable
-          attribute :path, :string
-          attribute :url, :string
-
-          yaml do
-            map "path", to: :path
-            map "url", to: :url
-          end
-        end
-
-        # Logo configuration (square, long, etc.)
-        class LogoConfig < Lutaml::Model::Serializable
-          attribute :light, LogoVariant
-          attribute :dark, LogoVariant
-
-          yaml do
-            map "light", to: :light
-            map "dark", to: :dark
-          end
-        end
-
-        # Logos container
-        class LogosConfig < Lutaml::Model::Serializable
-          attribute :square, LogoConfig
-          attribute :long, LogoConfig
-
-          yaml do
-            map "square", to: :square
-            map "long", to: :long
-          end
-        end
-
-        # Appearance configuration
-        class AppearanceConfig < Lutaml::Model::Serializable
-          attribute :logos, LogosConfig
-          attribute :favicon, :string # Will be array of hashes
-          attribute :colors, :string # Will be hash
-          attribute :typography, :string # Will be hash
-          attribute :custom_css, :string
-          attribute :layout, :string # Will be hash
-
-          yaml do
-            map "logos", to: :logos
-            map "favicon", to: :favicon
-            map "colors", to: :colors
-            map "typography", to: :typography
-            map "custom_css", to: :custom_css
-            map "layout", to: :layout
-          end
-        end
-
-        # Author configuration
-        class AuthorConfig < Lutaml::Model::Serializable
-          attribute :name, :string
-          attribute :email, :string
-
-          yaml do
-            map "name", to: :name
-            map "email", to: :email
-          end
-        end
-
-        # External link configuration
-        class LinkConfig < Lutaml::Model::Serializable
-          attribute :name, :string
-          attribute :url, :string
-
-          yaml do
-            map "name", to: :name
-            map "url", to: :url
-          end
-        end
-
-        # Metadata configuration
-        class MetadataConfig < Lutaml::Model::Serializable
-          attribute :name, :string
-          attribute :title, :string
-          attribute :description, :string
-          attribute :version, :string
-          attribute :license, :string
-          attribute :license_url, :string
-          attribute :authors, AuthorConfig, collection: true
-          attribute :homepage, :string
-          attribute :repository, :string
-          attribute :documentation, :string
-          attribute :tags, :string, collection: true
-          attribute :links, LinkConfig, collection: true
-          attribute :appearance, AppearanceConfig
-
-          yaml do
-            map "name", to: :name
-            map "title", to: :title
-            map "description", to: :description
-            map "version", to: :version
-            map "license", to: :license
-            map "license_url", to: :license_url
-            map "authors", to: :authors
-            map "homepage", to: :homepage
-            map "repository", to: :repository
-            map "documentation", to: :documentation
-            map "tags", to: :tags
-            map "links", to: :links
-            map "appearance", to: :appearance
-          end
-        end
-
-        # Main configuration attributes
-        attribute :version, :string
-        attribute :description, :string
-        attribute :metadata, MetadataConfig
-        attribute :output, OutputConfig
-        attribute :templates, :string # Will be hash
-        attribute :data_transformation, :string # Will be hash
-        attribute :search, SearchConfig
-        attribute :assets, :string # Will be hash
-        attribute :ui, UIConfig
-        attribute :features, :string # Will be hash
-        attribute :plugins, :string # Will be hash
-        attribute :performance, :string # Will be hash
-        attribute :accessibility, :string # Will be hash
-
-        yaml do
-          map "version", to: :version
-          map "description", to: :description
-          map "metadata", to: :metadata
-          map "output", to: :output
-          map "templates", to: :templates
-          map "data_transformation", to: :data_transformation
-          map "search", to: :search
-          map "assets", to: :assets
-          map "ui", to: :ui
-          map "features", to: :features
-          map "plugins", to: :plugins
-          map "performance", to: :performance
-          map "accessibility", to: :accessibility
-        end
-
-        class << self
-          # Load configuration from YAML file
-          #
-          # @param config_path [String, nil] Path to configuration file
-          # @return [Configuration] Loaded configuration
-          def load(config_path = nil)
-            config_path ||= default_config_path
-
-            unless File.exist?(config_path)
-              return create_default_configuration
-            end
-
-            yaml_content = File.read(config_path)
-            from_yaml(yaml_content)
-          end
-
-          # Get default configuration file path
-          #
-          # @return [String] Path to default config
-          def default_config_path
-            File.expand_path("../../../../config/static_site.yml", __dir__)
-          end
-
-          # Create default configuration programmatically
-          #
-          # @return [Configuration] Default configuration
-          def create_default_configuration
-            new.tap do |config|
-              config.version = "1.0"
-              config.description = "Default Static Site Configuration"
-            end
-          end
-        end
-
-        # Get data transformation options as hash
-        #
-        # @return [Hash] Transformation options
-        def transformation_options
-          @transformation_options ||= parse_hash_attribute(data_transformation)
-        end
-
-        # Get features as hash
-        #
-        # @return [Hash] Feature flags
-        def feature_flags
-          @feature_flags ||= parse_hash_attribute(features)
-        end
-
-        # Check if a feature is enabled
-        #
-        # @param feature_name [String, Symbol] Feature name
-        # @return [Boolean] true if feature is enabled
-        def feature_enabled?(feature_name)
-          flags = feature_flags
-          return false if flags.nil? || flags.empty?
-
-          flags[feature_name.to_s] == true
-        end
-
-        private
-
-        def parse_hash_attribute(attr) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          case attr
-          when Hash
-            attr
-          when String
-            # Try to parse as YAML first
-            begin
-              parsed = YAML.safe_load(attr, permitted_classes: [Symbol])
-              return parsed if parsed.is_a?(Hash)
-            rescue StandardError
-              # Fall through to eval if YAML parsing fails
-            end
-
-            # If the string looks like a Ruby hash (contains =>),
-            # try to evaluate it safely
-            if attr.include?("=>")
-              begin
-                # Use eval in a controlled way - this is safe because we
-                # control the input
-                # The string comes from our own YAML config file
-                parsed = eval(attr) # rubocop:disable Security/Eval
-                return parsed if parsed.is_a?(Hash)
-              rescue StandardError
-                # Fall through to empty hash
-              end
-            end
-
-            {}
-          else
-            {}
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      class DataTransformer
-        include Lutaml::Uml::ModelHelpers
-
-        attr_reader :repository, :id_generator, :options
-
-        def initialize(repository, options = {})
-          @repository = repository
-          @options = default_options.merge(options)
-          @id_generator = IdGenerator.new
-          @generalization_map = build_generalization_map
-        end
-
-        def transform
-          Models::SpaDocument.new(
-            metadata: Serializers::MetadataBuilder.new(repository,
-                                                       @options[:config]).build,
-            package_tree: build_package_tree,
-            packages: build_packages_map,
-            classes: build_classes_map,
-            attributes: build_attributes_map,
-            associations: build_associations_map,
-            operations: build_operations_map,
-            diagrams: build_diagrams_map,
-          )
-        end
-
-        private
-
-        def default_options
-          {
-            include_diagrams: true,
-            format_definitions: true,
-            max_definition_length: nil,
-          }
-        end
-
-        def inheritance_resolver
-          @inheritance_resolver ||= Serializers::InheritanceResolver.new(
-            repository, id_generator, options, @generalization_map
-          )
-        end
-
-        def build_generalization_map
-          map = Hash.new { |h, k| h[k] = [] }
-
-          repository.classes_index.each do |klass|
-            add_generalization_entries(map, klass)
-          end
-
-          map
-        end
-
-        def class_lookup
-          @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_associations_map
-          Serializers::AssociationSerializer.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)
-          return nil unless assoc_gen
-
-          if assoc_gen.is_a?(String)
-            return nil if assoc_gen.empty?
-
-            found = class_lookup.by_xmi_id(assoc_gen)
-            return found ? assoc_gen : nil
-          end
-
-          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
-      end
-    end
-  end
-end

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

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Lutaml
-  module UmlRepository
-    module StaticSite
-      # Orchestrates static site generation.
-      #
-      # Thin coordinator that delegates to:
-      # - DataTransformer for building the typed SpaDocument
-      # - SearchIndexBuilder for building the typed SpaSearchIndex
-      # - Output::Strategy subclass for rendering HTML
-      #
-      # @example Single-file Vue IIFE output
-      #   generator = Generator.new(repository,
-      #     output_strategy: Output::VueInlinedStrategy,
-      #     output: "browser.html")
-      #   generator.generate
-      class Generator
-        attr_reader :repository, :config, :options, :id_generator,
-                    :data_transformer, :search_builder
-
-        def initialize(repository, options = {})
-          @repository = repository
-          @config = options[:config] ||
-            Configuration.load(options[:config_path])
-          @options = build_options(options)
-
-          @id_generator = options[:id_generator] || IdGenerator.new
-          @data_transformer = options[:data_transformer] ||
-            create_data_transformer
-          @search_builder = options[:search_builder] ||
-            create_search_builder
-
-          @output_strategy = resolve_strategy(options)
-        end
-
-        def generate
-          spa_document = @data_transformer.transform
-          search_index = @search_builder.build
-
-          @output_strategy.render(spa_document, search_index)
-        end
-
-        private
-
-        def build_options(user_options)
-          defaults = {
-            mode: :single_file,
-            output: determine_default_output,
-          }
-
-          config_options = {
-            title: @config.ui&.title,
-            description: @config.ui&.description,
-          }.compact
-
-          defaults.merge(config_options).merge(user_options)
-        end
-
-        def determine_default_output
-          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 resolve_strategy(options)
-          strategy_class = options[:output_strategy]
-          if strategy_class
-            return strategy_class.new(@options[:output],
-                                      config: @config)
-          end
-
-          case @options[:mode]
-          when :single_file
-            Output::VueInlinedStrategy.new(@options[:output], config: @config)
-          when :multi_file
-            Output::MultiFileStrategy.new(@options[:output], config: @config)
-          else
-            raise ArgumentError,
-                  "Invalid mode: #{@options[:mode]}. " \
-                  "Use :single_file or :multi_file"
-          end
-        end
-
-        def create_data_transformer
-          DataTransformer.new(@repository,
-                              transformer_options.merge(config: @config))
-        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
-          {
-            fields: @config.search&.fields,
-            document_types: @config.search&.document_types,
-            stop_words: @config.search&.stop_words,
-          }
-        end
-      end
-    end
-  end
-end