coradoc-html 1.1.7

data/lib/coradoc/html/theme/modern_renderer.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Theme
+      # Modern theme renderer using Vue.js 3 + Tailwind CSS
+      #
+      # This renderer generates a complete, self-contained HTML5 document
+      # with embedded Vue.js components and Tailwind CSS styling.
+      # The modern theme features glass morphism aesthetics and interactive
+      # UI components.
+      #
+      # @example Generate modern HTML output
+      #   html = Coradoc::Output::Html.convert_to_html5(document, theme: :modern)
+      class ModernRenderer < Base
+        autoload :Serializers, "#{__dir__}/modern/serializers/document_serializer"
+        autoload :JavascriptGenerator, "#{__dir__}/modern/javascript_generator"
+        autoload :TailwindConfigBuilder, "#{__dir__}/modern/tailwind_config_builder"
+        autoload :CSSGenerator, "#{__dir__}/modern/css_generator"
+        autoload :UIComponents, "#{__dir__}/modern/components/ui_components"
+
+        # Register this theme
+        Registry.register(:modern, self)
+
+        # Default configuration for modern theme
+        DEFAULT_CONFIG = {
+          color_scheme: :glass,
+          primary_color: '#6366f1',    # Indigo-500
+          accent_color: '#8b5cf6',     # Violet-500
+          max_width: '1200px',
+          content_width: '65ch',
+          sidebar_width: '280px',
+          theme_toggle: true,
+          reading_progress: true,
+          back_to_top: true,
+          toc_sticky: true,
+          copy_code_buttons: true,
+          enable_animations: true,
+          animation_duration: '300ms',
+          lazy_load_images: true
+        }.freeze
+
+        # Get template directories (from options or global config)
+        #
+        # @return [Array<String>]
+        def template_dirs
+          @options[:template_dirs] || global_template_dirs
+        end
+
+        # Check if custom templates are configured and available
+        #
+        # @return [Boolean]
+        def use_custom_templates?
+          dirs = template_dirs
+          return false if dirs.empty?
+
+          dirs.any? { |dir| File.directory?(dir) }
+        end
+
+        # Supported features for modern theme
+        #
+        # @return [Array<Symbol>] Supported features
+        def supported_features
+          %i[
+            dark_mode
+            theme_toggle
+            interactive_toc
+            reading_progress
+            back_to_top
+            copy_code_buttons
+            lazy_loading
+            animations
+            glass_morphism
+          ]
+        end
+
+        # Render document to HTML
+        #
+        # Generates a complete HTML5 document with Vue.js application.
+        #
+        # @return [String] Complete HTML5 document
+        def render
+          render_html5
+        end
+
+        # Render complete HTML5 document
+        #
+        # @return [String] Complete HTML5 document
+        def render_html5
+          # Merge user options with defaults
+          config = DEFAULT_CONFIG.merge(@options[:modern] || {})
+
+          # Serialize document to Vue-compatible format
+          document_data = serialize_document
+
+          # Generate Vue application code
+          vue_app = generate_vue_app(document_data, config)
+
+          # Generate Tailwind configuration
+          tailwind_config = generate_tailwind_config(config)
+
+          # Generate custom CSS
+          custom_css = generate_custom_css(config)
+
+          # Build complete HTML document
+          build_html_document(vue_app, tailwind_config, custom_css, config)
+        end
+
+        private
+
+        # Get global template directories from configuration
+        def global_template_dirs
+          Coradoc::Html.configuration.template_dirs.map(&:to_s)
+        end
+
+        # Serialize document to Vue-compatible data structure
+        #
+        # @return [Hash] Serialized document data
+        def serialize_document
+          Serializers::DocumentSerializer.serialize(@document)
+        end
+
+        # Generate Vue application code
+        #
+        # @param document_data [Hash] Serialized document data
+        # @param config [Hash] Theme configuration
+        # @return [String] Vue application JavaScript
+        def generate_vue_app(document_data, config)
+          JavascriptGenerator.generate(document_data, config)
+        end
+
+        # Generate Tailwind CSS configuration
+        #
+        # @param config [Hash] Theme configuration
+        # @return [String] Tailwind configuration script
+        def generate_tailwind_config(config)
+          TailwindConfigBuilder.build(config)
+        end
+
+        # Generate custom CSS for glass morphism and special effects
+        #
+        # @param config [Hash] Theme configuration
+        # @return [String] Custom CSS
+        def generate_custom_css(config)
+          UIComponents.enhanced_css(config)
+        end
+
+        # Build complete HTML document
+        #
+        # @param vue_app [String] Vue application code
+        # @param tailwind_config [String] Tailwind configuration
+        # @param custom_css [String] Custom CSS
+        # @param config [Hash] Theme configuration
+        # @return [String] Complete HTML5 document
+        def build_html_document(vue_app, tailwind_config, custom_css, config)
+          lang = @options[:lang] || 'en'
+          title = extract_document_title
+
+          # Meta tags
+          meta_tags = build_meta_tags(config)
+
+          # Open Graph tags if enabled
+          og_tags = config[:open_graph] ? build_open_graph_tags : ''
+
+          # Vue and Tailwind CDN links
+          cdn_links = build_cdn_links
+
+          <<~HTML
+            <!DOCTYPE html>
+            <html lang="#{lang}" class="#{config[:color_scheme]}">
+            <head>
+              <meta charset="UTF-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1.0">
+              #{meta_tags}
+              <title>#{escape_html(title)}</title>
+              #{og_tags}
+              #{cdn_links}
+              <script>#{tailwind_config}</script>
+              <style>#{custom_css}</style>
+            </head>
+            <body class="bg-gradient-to-br from-slate-50 to-slate-100 dark:from-slate-900 dark:to-slate-800 min-h-screen transition-colors duration-300">
+              <div id="app"></div>
+              <script>#{vue_app}</script>
+            </body>
+            </html>
+          HTML
+        end
+
+        # Build meta tags
+        #
+        # @param config [Hash] Theme configuration
+        # @return [String] Meta tags HTML
+        def build_meta_tags(config)
+          tags = []
+
+          # Author
+          tags << %(<meta name="author" content="#{escape_attr(@options[:author])}">) if @options[:author]
+
+          # Description
+          description = config[:meta_description] || @options[:description]
+          tags << %(<meta name="description" content="#{escape_attr(description)}">) if description
+
+          # Keywords
+          keywords = config[:meta_keywords] || @options[:keywords]
+          tags << %(<meta name="keywords" content="#{escape_attr(keywords)}">) if keywords
+
+          # Generator
+          tags << %{<meta name="generator" content="Coradoc #{Coradoc::VERSION} (Modern Theme)">}
+
+          # Timestamp
+          tags << %(<meta name="generated" content="#{Time.now.utc.iso8601}">)
+
+          # Custom meta tags
+          if @options[:meta_tags].is_a?(Hash)
+            @options[:meta_tags].each do |name, content|
+              tags << %(<meta name="#{escape_attr(name)}" content="#{escape_attr(content)}">)
+            end
+          end
+
+          tags.join("\n  ")
+        end
+
+        # Build Open Graph tags
+        #
+        # @return [String] Open Graph tags HTML
+        def build_open_graph_tags
+          title = extract_document_title
+          <<~HTML
+            <meta property="og:title" content="#{escape_html(title)}">
+            <meta property="og:type" content="article">
+            <meta property="og:generator" content="Coradoc #{Coradoc::VERSION}">
+          HTML
+        end
+
+        # Build CDN links for Vue and Tailwind
+        #
+        # @return [String] CDN link tags
+        def build_cdn_links
+          <<~HTML
+            <!-- Vue.js 3 (with template compiler for runtime compilation) -->
+            <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>
+
+            <!-- Tailwind CSS 3.4 -->
+            <script src="https://cdn.tailwindcss.com"></script>
+          HTML
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/theme/registry.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Theme
+      # Theme registry for managing and retrieving theme renderers
+      #
+      # The registry maintains a collection of available themes and provides
+      # methods for registration, lookup, and validation.
+      #
+      # @example Registering a custom theme
+      #   class MyCustomTheme < Coradoc::Html::Theme::Base
+      #     def render
+      #       "<h1>Custom HTML</h1>"
+      #     end
+      #   end
+      #
+      #   Coradoc::Html::Theme::Registry.register(:my_custom, MyCustomTheme)
+      #
+      # @example Using a theme
+      #   renderer = Coradoc::Html::Theme::Registry.find(:my_custom)
+      #   renderer.new(document, options).render
+      class Registry
+        class << self
+          # Registered themes mapping
+          #
+          # @return [Hash] Theme name to renderer class mapping
+          def themes
+            @themes ||= {}
+          end
+
+          # Register a theme renderer
+          #
+          # @param name [Symbol] Theme name (e.g., :classic, :modern)
+          # @param renderer_class [Class] Theme renderer class
+          # @raise [ArgumentError] if renderer_class is not a Theme::Base subclass
+          #
+          # @example Register a theme
+          #   Registry.register(:my_theme, MyThemeRenderer)
+          def register(name, renderer_class)
+            unless renderer_class.is_a?(Class) &&
+                   renderer_class <= Coradoc::Html::Theme::Base
+              raise ArgumentError,
+                    'Theme renderer must be a subclass of Coradoc::Html::Theme::Base, ' \
+                    "got: #{renderer_class}"
+            end
+
+            themes[name] = renderer_class
+          end
+
+          # Find a theme renderer by name
+          #
+          # @param name [Symbol] Theme name
+          # @return [Class, nil] Theme renderer class or nil if not found
+          #
+          # @example Find a theme
+          #   renderer = Registry.find(:modern)
+          def find(name)
+            themes[name]
+          end
+
+          # Check if a theme is registered
+          #
+          # @param name [Symbol] Theme name
+          # @return [Boolean] true if theme is registered
+          #
+          # @example Check theme existence
+          #   Registry.registered?(:modern) # => true
+          def registered?(name)
+            themes.key?(name)
+          end
+
+          # Get all registered theme names
+          #
+          # @return [Array<Symbol>] List of registered theme names
+          #
+          # @example List all themes
+          #   Registry.all_theme_names # => [:classic, :modern]
+          def all_theme_names
+            themes.keys.sort
+          end
+
+          # Get default theme name
+          #
+          # @return [Symbol] Default theme name
+          def default_theme
+            :classic
+          end
+
+          # Resolve theme from options
+          #
+          # Returns the theme renderer class based on the provided options.
+          # Falls back to default theme if not specified or if theme not found.
+          #
+          # @param options [Hash] Rendering options
+          # @return [Class] Theme renderer class
+          #
+          # @example Resolve theme from options
+          #   renderer = Registry.resolve_from_options(theme: :modern)
+          def resolve_from_options(options = {})
+            theme_name = options.fetch(:theme, default_theme)
+
+            renderer_class = find(theme_name)
+            return renderer_class if renderer_class
+
+            # Theme not found, fall back to default
+            Coradoc::Logger.warn(
+              "Theme '#{theme_name}' not found, falling back to '#{default_theme}'"
+            )
+
+            find(default_theme) || raise("Default theme '#{default_theme}' not registered")
+          end
+
+          # Auto-register a theme class
+          #
+          # This method is called by theme classes when they are loaded.
+          # It extracts the theme name from the class name and registers it.
+          #
+          # @param renderer_class [Class] Theme renderer class
+          #
+          # @example Auto-register from within a theme class
+          #   class ModernTheme < Coradoc::Output::Html::Theme::Base
+          #     Coradoc::Output::Html::Theme::Registry.auto_register(self)
+          #   end
+          def auto_register(renderer_class)
+            # Extract theme name from class name
+            # e.g., ModernRenderer -> :modern, ClassicRenderer -> :classic
+            class_name = renderer_class.name.split('::').last
+
+            # Remove "Renderer" suffix if present
+            theme_name = class_name.sub(/Renderer$/, '')
+                                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                                   .downcase
+                                   .to_sym
+
+            register(theme_name, renderer_class)
+          end
+
+          # Clear all registered themes (mainly for testing)
+          #
+          # @return [void]
+          #
+          # @example Clear registry
+          #   Registry.clear
+          def clear
+            @themes = {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/theme.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Theme
+      # Autoload Theme components
+      autoload :Base, 'coradoc/html/theme/base'
+      autoload :Registry, 'coradoc/html/theme/registry'
+      autoload :ClassicRenderer, 'coradoc/html/theme/classic_renderer'
+      autoload :ModernRenderer, 'coradoc/html/theme/modern_renderer'
+    end
+  end
+end

data/lib/coradoc/html/transform/from_core_model.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Transform
+      # Transforms CoreModel models to HTML output
+      #
+      # This transformer converts CoreModel to structures suitable for
+      # HTML rendering. Note: The HTML converters already support CoreModel
+      # directly, so this transformer primarily passes through the CoreModel.
+      class FromCoreModel
+        class << self
+          # Transform a CoreModel to HTML-ready structure
+          #
+          # @param model [Coradoc::CoreModel::Base] CoreModel to transform
+          # @return [Object] HTML-ready structure
+          def transform(model)
+            case model
+            when Coradoc::CoreModel::Base
+              # HTML converters already support CoreModel directly
+              model
+            when Array
+              model.map { |item| transform(item) }
+            else
+              model
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/transform/to_core_model.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'coradoc/core_model'
+
+module Coradoc
+  module Html
+    module Transform
+      # Transforms HTML input models to CoreModel equivalents
+      #
+      # HTML input converters now produce CoreModel directly, so this transformer
+      # is largely a pass-through that ensures the model is CoreModel.
+      class ToCoreModel
+        class << self
+          # Transform an HTML input model to CoreModel
+          #
+          # @param model [Object] HTML input model to transform
+          # @return [Coradoc::CoreModel::Base] CoreModel equivalent
+          def transform(model)
+            # HTML input now produces CoreModel directly
+            transform_direct(model)
+          end
+
+          private
+
+          def transform_direct(model)
+            case model
+            when Coradoc::CoreModel::Base
+              model
+            when Array
+              model.map { |item| transform(item) }
+            else
+              model
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    VERSION = '1.1.7'
+  end
+end