coradoc-html 1.1.7 → 1.1.13

data/lib/coradoc/html/input/converters.rb

@@ -16,19 +16,21 @@ module Coradoc
         autoload :Code, 'coradoc/html/input/converters/code'
         autoload :Div, 'coradoc/html/input/converters/div'
         autoload :Dl, 'coradoc/html/input/converters/dl'
-        autoload :Drop, 'coradoc/html/input/converters/drop'
+        autoload :Skip, 'coradoc/html/input/converters/drop'
         autoload :Em, 'coradoc/html/input/converters/em'
         autoload :Figure, 'coradoc/html/input/converters/figure'
         autoload :H, 'coradoc/html/input/converters/h'
         autoload :Head, 'coradoc/html/input/converters/head'
         autoload :Hr, 'coradoc/html/input/converters/hr'
-        autoload :Ignore, 'coradoc/html/input/converters/ignore'
         autoload :Img, 'coradoc/html/input/converters/img'
         autoload :Li, 'coradoc/html/input/converters/li'
         autoload :Mark, 'coradoc/html/input/converters/mark'
+        autoload :Math, 'coradoc/html/input/converters/math'
+        autoload :MediaBase, 'coradoc/html/input/converters/media_base'
         autoload :Ol, 'coradoc/html/input/converters/ol'
         autoload :P, 'coradoc/html/input/converters/p'
         autoload :PassThrough, 'coradoc/html/input/converters/pass_through'
+        autoload :PositionalFormatting, 'coradoc/html/input/converters/positional_formatting'
         autoload :Pre, 'coradoc/html/input/converters/pre'
         autoload :Q, 'coradoc/html/input/converters/q'
         autoload :Strong, 'coradoc/html/input/converters/strong'
@@ -37,55 +39,35 @@ module Coradoc
         autoload :Table, 'coradoc/html/input/converters/table'
         autoload :Td, 'coradoc/html/input/converters/td'
         autoload :Text, 'coradoc/html/input/converters/text'
-        autoload :Th, 'coradoc/html/input/converters/th'
         autoload :Tr, 'coradoc/html/input/converters/tr'
         autoload :Video, 'coradoc/html/input/converters/video'
-        autoload :Math, 'coradoc/html/input/converters/math'
 
-        # Define class methods
+        @converters = {}
+        @converters_loaded = false
+
         def self.register(tag_name, converter)
-          @@converters ||= {}
-          @@converters[tag_name.to_sym] = converter
+          @converters[tag_name.to_sym] = converter
         end
 
         def self.unregister(tag_name)
-          @@converters.delete(tag_name.to_sym)
+          @converters.delete(tag_name.to_sym)
         end
 
-        # Ensure all converters are loaded and registered before first use
         def self.ensure_converters_loaded
           return if @converters_loaded
 
           @converters_loaded = true
 
-          # Access each autoloaded constant to trigger file load + registration
-          # Only load converters that register HTML tag handlers
-          # Note: Some converters may have gem dependencies (e.g., Img requires marcel)
-          # so we only load the essential ones here
           [
-            Base, Markup, A, Aside, Blockquote, Br, Bypass, Code, Div, Dl,
-            Drop, Em, Figure, H, Head, Hr, Ignore, Li, Mark, Ol, P,
-            PassThrough, Pre, Q, Strong, Sup, Sub, Table, Td, Text, Th, Tr
-          ].each do |converter|
-            # Just accessing the constant triggers autoload
-          end
+            Base, Markup, A, Aside, Audio, Blockquote, Br, Bypass, Code, Div, Dl,
+            Skip, Em, Figure, H, Head, Hr, Img, Li, Mark, Math, Ol, P,
+            PassThrough, Pre, Q, Strong, Sup, Sub, Table, Td, Text, Tr, Video
+          ].each { |converter| _ = converter }
         end
 
         def self.lookup(tag_name)
           ensure_converters_loaded
-          converter = @@converters[tag_name.to_sym] || default_converter(tag_name)
-          converter.is_a?(Class) ? converter.new : converter
-        end
-
-        # NOTE: process won't run plugin hooks
-        def self.process(node, state)
-          node = node.to_a if node.is_a? Nokogiri::XML::NodeSet
-          if node.is_a? Array
-            return node.map { |i| process(i, state) }
-                       .join
-          end
-
-          lookup(node.name).convert(node, state)
+          @converters[tag_name.to_sym] || default_converter(tag_name)
         end
 
         def self.process_coradoc(node, state)
@@ -104,11 +86,11 @@ module Coradoc
         def self.default_converter(tag_name)
           case Html.config.unknown_tags.to_sym
           when :pass_through
-            PassThrough.new
+            PassThrough::INSTANCE
           when :drop
-            Drop.new
+            Skip::INSTANCE
           when :bypass
-            Bypass.new
+            Bypass::INSTANCE
           when :raise
             raise Errors::UnknownTagError, "unknown tag: #{tag_name}"
           else

data/lib/coradoc/html/input/html_converter.rb

@@ -41,10 +41,8 @@ module Coradoc
 
             plugin_instances.each do |plugin|
               plugin.html_tree = root
-              if plugin.public_methods.include?(:preprocess_html_tree)
-                track_time "Preprocessing document with #{plugin.name} plugin" do
-                  plugin.preprocess_html_tree
-                end
+              track_time "Preprocessing document with #{plugin.name} plugin" do
+                plugin.preprocess_html_tree
               end
               root = plugin.html_tree
             end
@@ -61,8 +59,6 @@ module Coradoc
             end
 
             plugin_instances.each do |plugin|
-              next unless plugin.public_methods.include?(:postprocess_coremodel_tree)
-
               plugin.coremodel_tree = coremodel
               track_time "Postprocessing CoreModel tree with #{plugin.name} plugin" do
                 plugin.postprocess_coremodel_tree
@@ -76,74 +72,6 @@ module Coradoc
           end
         end
 
-        # Legacy method - returns CoreModel
-        # @deprecated Use {#to_core_model} instead
-        def self.to_coradoc(input, options = {})
-          to_core_model(input, options)
-        end
-
-        # Legacy method for backward compatibility
-        # Converts HTML to CoreModel, then serializes to target format
-        #
-        # @deprecated Use {#to_core_model} + Coradoc.serialize instead
-        # @param input [String] HTML input
-        # @param options [Hash] Conversion options
-        # @param options [Symbol] :output_format Target format (default: :asciidoc)
-        # @return [String] Serialized document in target format
-        def self.convert(input, options = {})
-          output_format = options.delete(:output_format) || :asciidoc
-
-          coremodel = to_core_model(input, options)
-
-          if coremodel.is_a?(Hash)
-            coremodel.to_h do |file, tree|
-              track_time "Serializing file #{file || 'main'}" do
-                [file, serialize_core_model(tree, output_format, options)]
-              end
-            end
-          else
-            serialize_core_model(coremodel, output_format, options)
-          end
-        end
-
-        # Serialize CoreModel to target format using the appropriate gem
-        #
-        # @param coremodel [Coradoc::CoreModel::Base] CoreModel document
-        # @param format [Symbol] Target format
-        # @param options [Hash] Serialization options
-        # @return [String] Serialized document
-        def self.serialize_core_model(coremodel, format, options = {})
-          result = Coradoc.serialize(coremodel, to: format)
-          cleanup_result(result, options)
-        end
-
-        # Clean up the serialized result
-        #
-        # @param result [String] Serialized result
-        # @param options [Hash] Cleanup options
-        # @return [String] Cleaned result
-        def self.cleanup_result(result, options = {})
-          Input::Html.config.with(options) do
-            plugin_instances = prepare_plugin_instances(options)
-
-            result = track_time 'Cleaning up the result' do
-              Input::Html.cleaner.tidy(result)
-            end
-
-            plugin_instances.each do |plugin|
-              next unless plugin.public_methods.include?(:postprocess_output_string)
-
-              plugin.output_string = result
-              track_time "Postprocessing output string with #{plugin.name} plugin" do
-                plugin.postprocess_output_string
-              end
-              result = plugin.output_string
-            end
-
-            result
-          end
-        end
-
         def self.prepare_plugin_instances(options)
           options[:plugin_instances] || Html.config.plugins.map(&:new)
         end

data/lib/coradoc/html/input/plugin.rb

@@ -11,9 +11,9 @@ module Coradoc
         #   def name = "Test"
         # end
 
-        def self.new(&block)
+        def self.new(&)
           if self == Plugin
-            Class.new(Plugin, &block)
+            Class.new(Plugin, &)
           else
             super
           end
@@ -24,38 +24,19 @@ module Coradoc
           @html_tree_hooks_post = {}
         end
 
-        # define name to name a Plugin
         def name
           self.class.name
         end
 
+        # Default no-op hooks. Plugins override these as needed.
+        def preprocess_html_tree; end
+        def postprocess_coremodel_tree; end
+        def postprocess_output_string; end
+
         #### HTML Tree functionalities
 
         attr_accessor :html_tree, :coremodel_tree, :output_string
 
-        # Legacy accessors for backward compatibility
-        # @deprecated Use coremodel_tree instead. Will be removed in v2.0.
-        def coradoc_tree
-          warn '[DEPRECATION] `coradoc_tree` is deprecated. Use `coremodel_tree` instead.'
-          coremodel_tree
-        end
-
-        def coradoc_tree=(value)
-          warn '[DEPRECATION] `coradoc_tree=` is deprecated. Use `coremodel_tree=` instead.'
-          self.coremodel_tree = value
-        end
-
-        # @deprecated Use output_string instead. Will be removed in v2.0.
-        def asciidoc_string
-          warn '[DEPRECATION] `asciidoc_string` is deprecated. Use `output_string` instead.'
-          output_string
-        end
-
-        def asciidoc_string=(value)
-          warn '[DEPRECATION] `asciidoc_string=` is deprecated. Use `output_string=` instead.'
-          self.output_string = value
-        end
-
         def html_tree_change_tag_name_by_css(css, new_name)
           html_tree.css(css).each do |e|
             e.name = new_name
@@ -84,12 +65,6 @@ module Coradoc
           Coradoc::Html::Input::Converters.process_coradoc(tree, state)
         end
 
-        # @deprecated Use html_tree_process_to_coremodel instead. Will be removed in v2.0.
-        def html_tree_process_to_coradoc(tree, state = {})
-          warn '[DEPRECATION] `html_tree_process_to_coradoc` is deprecated. Use `html_tree_process_to_coremodel` instead.'
-          html_tree_process_to_coremodel(tree, state)
-        end
-
         def html_tree_preview
           Tempfile.open(%w[coradoc .html]) do |i|
             i << html_tree.to_html
@@ -131,7 +106,7 @@ module Coradoc
           end
         end
 
-        def html_tree_run_hooks(node, state, &_block)
+        def html_tree_run_hooks(node, state, &)
           hook_pre = @html_tree_hooks_pre[node]
           hook_post = @html_tree_hooks_post[node]
 
@@ -145,24 +120,7 @@ module Coradoc
 
         #### CoreModel tree functionalities
 
-        # define postprocess_coremodel_tree to change CoreModel tree
-
-        # @deprecated Use postprocess_coremodel_tree instead. Will be removed in v2.0.
-        def postprocess_coradoc_tree
-          warn '[DEPRECATION] `postprocess_coradoc_tree` is deprecated. Use `postprocess_coremodel_tree` instead.'
-          postprocess_coremodel_tree if public_methods.include?(:postprocess_coremodel_tree)
-        end
-
         #### Output string functionalities
-
-        # define postprocess_output_string to change the output string
-        # (regardless of target format)
-
-        # @deprecated Use postprocess_output_string instead. Will be removed in v2.0.
-        def postprocess_asciidoc_string
-          warn '[DEPRECATION] `postprocess_asciidoc_string` is deprecated. Use `postprocess_output_string` instead.'
-          postprocess_output_string if public_methods.include?(:postprocess_output_string)
-        end
       end
     end
   end

data/lib/coradoc/html/input/plugins/plateau.rb

@@ -16,15 +16,6 @@ module Coradoc
           end
 
           def preprocess_html_tree
-            # Let's simplify the tree by removing what's extraneous
-            # html_tree_remove_by_css("script, style, img.container_imagebox:not([src])")
-            # html_tree_replace_with_children_by_css("div.container_box")
-            # html_tree_replace_with_children_by_css("div.col.col-12")
-            # html_tree_replace_with_children_by_css(".tabledatatext, .tabledatatextY")
-            # html_tree_replace_with_children_by_css("div.row")
-            #
-            # We can remove that, but it messes up the images and paragraphs.
-
             # Remove side menu, so we can generate TOC ourselves
             html_tree_remove_by_css('.sideMenu')
 
@@ -87,7 +78,7 @@ module Coradoc
 
             # Handle non-semantic lists and indentation
             html_tree_add_hook_pre_by_css '.text2data' do |node,|
-              text = html_tree_process_to_adoc(node).strip
+              text = html_tree_process_to_coremodel(node).strip
               next '' if text.empty? || text == "\u3000"
 
               if text.start_with?(/\d+\./)
@@ -101,7 +92,7 @@ module Coradoc
 
             (3..4).each do |i|
               html_tree_add_hook_pre_by_css ".text#{i}data" do |node,|
-                text = html_tree_process_to_adoc(node).strip
+                text = html_tree_process_to_coremodel(node).strip
                 next '' if text.empty? || text == "\u3000"
 
                 text = text.strip.gsub(/^/, "#{'*' * i} ")
@@ -111,7 +102,7 @@ module Coradoc
 
             (2..3).each do |i|
               html_tree_add_hook_pre_by_css ".text#{i}data_point ul" do |node,|
-                text = html_tree_process_to_adoc(node.children.first.children).strip
+                text = html_tree_process_to_coremodel(node.children.first.children).strip
 
                 "#{'*' * i} #{text}\n"
               end
@@ -119,13 +110,11 @@ module Coradoc
 
             (1..20).each do |i|
               html_tree_add_hook_pre_by_css ".numtextdata_num .list_num#{i}" do |node,|
-                text = html_tree_process_to_adoc(node).strip
+                text = html_tree_process_to_coremodel(node).strip
 
                 "[start=#{i}]\n. #{text}\n"
               end
             end
-
-            # html_tree_preview
           end
 
           IM = /[A-Z0-9]{1,3}/
@@ -216,10 +205,6 @@ module Coradoc
 
             self.output_string = str
           end
-
-          # Legacy alias for backward compatibility
-          # @deprecated Use postprocess_output_string instead. Will be removed in v2.0.
-          alias postprocess_asciidoc_string postprocess_output_string
         end
       end
     end

data/lib/coradoc/html/input/postprocessor.rb

@@ -3,12 +3,10 @@
 module Coradoc
   module Input
     module Html
-      # Postprocessor's aim is to convert a Coradoc tree from
-      # a mess that has been created from HTML into a tree that
-      # is compatible with what we would get out of Coradoc, if
-      # it parsed it directly.
+      # Postprocessor hook for CoreModel tree transformations after HTML parsing.
       #
-      # Now operates on CoreModel types exclusively.
+      # Override or extend to apply post-parse cleanup. The default
+      # implementation returns the tree unchanged.
       class Postprocessor
         def self.process(coradoc)
           new(coradoc).process
@@ -18,11 +16,7 @@ module Coradoc
           @tree = coradoc
         end
 
-        # Main processing entry point
         def process
-          # For now, just return the tree as-is since CoreModel
-          # structure is already clean and well-formed.
-          # Future: implement CoreModel-based postprocessing
           @tree
         end
       end

data/lib/coradoc/html/input.rb

@@ -17,11 +17,11 @@ module Coradoc
       autoload :HtmlConverter, 'coradoc/html/input/html_converter'
 
       def self.convert(input, options = {})
-        HtmlConverter.convert(input, options)
+        HtmlConverter.to_core_model(input, options)
       end
 
       def self.to_coradoc(input, options = {})
-        HtmlConverter.to_coradoc(input, options)
+        HtmlConverter.to_core_model(input, options)
       end
 
       def self.config
@@ -38,8 +38,10 @@ module Coradoc
         :html
       end
 
+      extend Coradoc::Html::FormatDetection
+
       def self.processor_match?(filename)
-        %w[.html .htm].any? { |i| filename.downcase.end_with?(i) }
+        html_extension?(filename)
       end
 
       def self.processor_execute(input, options = {})
@@ -48,20 +50,36 @@ module Coradoc
 
       def self.processor_postprocess(data, options)
         if options[:output_processor] == :adoc
-          data.transform_values do |v|
-            Input::Html::HtmlConverter.cleanup_result(v, options)
-          end
+          data.transform_values { |v| clean_output(v, options) }
         else
           data
         end
       end
 
+      def self.clean_output(result, options = {})
+        config.with(options) do
+          plugin_instances = HtmlConverter.prepare_plugin_instances(options)
+
+          result = HtmlConverter.track_time('Cleaning up the result') do
+            cleaner.tidy(result)
+          end
+
+          plugin_instances.each do |plugin|
+            plugin.output_string = result
+            HtmlConverter.track_time("Postprocessing output string with #{plugin.name} plugin") do
+              plugin.postprocess_output_string
+            end
+            result = plugin.output_string
+          end
+
+          result
+        end
+      end
+
       Coradoc::Input.define(self)
     end
   end
 
-  # Backward compatibility alias
-  # Some legacy code references Coradoc::Html::Input instead of Coradoc::Input::Html
   module Html
     Input = Coradoc::Input::Html
   end

data/lib/coradoc/html/layout_renderer.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'liquid'
+
+module Coradoc
+  module Html
+    class LayoutRenderer
+      include TemplateCaching
+
+      LAYOUT_DIR = Pathname.new(File.join(File.dirname(__FILE__), 'templates', 'layouts'))
+
+      def initialize
+        @template_cache = {}
+        @dist_assets_cache = {}
+      end
+
+      def render_static(document, body_html, options)
+        layout_template = load_layout('default')
+        return build_static_fallback(document, body_html, options) unless layout_template
+
+        layout_template.render(build_static_layout_data(document, body_html, options)).strip
+      end
+
+      def render_spa(document, options, body_html, toc_data)
+        dist_dir = options[:dist_dir] || File.expand_path('../../../frontend/dist', __dir__)
+        assets = load_dist_assets(dist_dir)
+
+        content_data = build_spa_content_data(document, body_html, options, toc_data)
+        safe_json = Escape.safe_json(content_data)
+
+        layout_template = load_layout('spa')
+        if layout_template
+          layout_template.render(build_spa_layout_data(document, options, assets, safe_json)).strip
+        else
+          build_spa_fallback(document, options, assets, safe_json)
+        end
+      end
+
+      private
+
+      def resolve_title(document)
+        TitleText.resolve(document&.title) || Config::DEFAULT_TITLE
+      end
+
+      def resolve_escaped_title(document)
+        TitleText.escape(document&.title) || Config::DEFAULT_TITLE
+      end
+
+      def resolve_lang(options)
+        options[:lang] || Config::DEFAULT_LANG
+      end
+
+      def build_static_layout_data(document, body_html, options)
+        {
+          'lang' => resolve_lang(options),
+          'title' => resolve_escaped_title(document),
+          'author' => options[:author],
+          'description' => options[:description],
+          'generator_version' => Coradoc::VERSION.to_s,
+          'body' => body_html,
+          'custom_css' => options[:custom_css]
+        }
+      end
+
+      def build_static_fallback(document, body_html, options)
+        Nokogiri::HTML::Builder.new do |doc|
+          doc.html(lang: resolve_lang(options)) do
+            doc.head do
+              doc.meta(charset: 'UTF-8')
+              doc.meta(name: 'viewport', content: 'width=device-width, initial-scale=1.0')
+              doc.title resolve_title(document)
+            end
+            doc.body { doc << body_html }
+          end
+        end.to_html
+      end
+
+      def build_spa_content_data(document, body_html, options, toc_data)
+        {
+          mode: 'classic',
+          contentHtml: body_html,
+          toc: toc_data,
+          meta: build_spa_meta(document, options),
+          options: build_spa_options(options)
+        }
+      end
+
+      def build_spa_meta(document, options)
+        {
+          title: TitleText.resolve(document&.title) || Config::DEFAULT_TITLE,
+          author: options[:author],
+          date: options[:revdate],
+          generator: "Coradoc #{Coradoc::VERSION}"
+        }
+      end
+
+      def build_spa_options(options)
+        {
+          toc: options[:toc] ? true : false,
+          tocPlacement: (options[:toc_placement] || :auto).to_s,
+          sectnums: options[:section_numbers] == true,
+          themeToggle: options[:theme_toggle] != false,
+          readingProgress: options[:reading_progress] != false,
+          lang: resolve_lang(options)
+        }
+      end
+
+      def build_spa_layout_data(document, options, assets, safe_json)
+        {
+          'lang' => resolve_lang(options),
+          'title' => resolve_escaped_title(document),
+          'author' => options[:author],
+          'description' => options[:description],
+          'generator_version' => Coradoc::VERSION.to_s,
+          'css' => assets[:css],
+          'js' => assets[:js],
+          'data' => safe_json
+        }
+      end
+
+      def build_spa_fallback(document, options, assets, safe_json)
+        Nokogiri::HTML::Builder.new do |doc|
+          doc.html(lang: resolve_lang(options)) do
+            doc.head do
+              doc.meta(charset: 'UTF-8')
+              doc.meta(name: 'viewport', content: 'width=device-width, initial-scale=1.0')
+              doc.meta(name: 'generator', content: "Coradoc #{Coradoc::VERSION}")
+              doc.title resolve_title(document)
+              doc.style { doc.text assets[:css] } if assets[:css]
+            end
+            doc.body do
+              doc.div(id: 'coradoc-app')
+              doc.script { doc << "window.CORADOC_DATA = #{safe_json};" }
+              doc.script { doc << assets[:js] } if assets[:js]
+            end
+          end
+        end.to_html
+      end
+
+      def load_layout(name)
+        cache_key = "layout:#{name}"
+        path = LAYOUT_DIR.join("#{name}.liquid").to_s
+        load_template(cache: @template_cache, cache_key: cache_key, path: path)
+      end
+
+      def load_dist_assets(dist_dir)
+        @dist_assets_cache[dist_dir] ||= begin
+          unless File.directory?(dist_dir)
+            raise ArgumentError,
+                  "Frontend dist directory not found: #{dist_dir}. " \
+                  'Build the frontend first: cd frontend && npm install && npm run build'
+          end
+
+          {
+            css: File.read(File.join(dist_dir, 'app.css')),
+            js: File.read(File.join(dist_dir, 'app.iife.js'))
+          }
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/output.rb

@@ -16,18 +16,15 @@ module Coradoc
     #   result = Coradoc::Output.process(document, format: :html_static)
     #
     class HtmlStatic
+      extend Coradoc::Html::FormatDetection
+
       class << self
-        # Processor identifier for registration
-        # @return [Symbol] the processor ID
         def processor_id
           :html_static
         end
 
-        # Check if this processor matches a given filename
-        # @param filename [String] the filename to check
-        # @return [Boolean] true if this processor handles the file type
         def processor_match?(filename)
-          %w[.html .htm].any? { |ext| filename.downcase.end_with?(ext) }
+          html_extension?(filename)
         end
 
         # Process documents to static HTML
@@ -56,18 +53,15 @@ module Coradoc
     #   result = Coradoc::Output.process(document, format: :html_spa)
     #
     class HtmlSpa
+      extend Coradoc::Html::FormatDetection
+
       class << self
-        # Processor identifier for registration
-        # @return [Symbol] the processor ID
         def processor_id
           :html_spa
         end
 
-        # Check if this processor matches a given filename
-        # @param filename [String] the filename to check
-        # @return [Boolean] true if this processor handles the file type
         def processor_match?(filename)
-          %w[.html .htm].any? { |ext| filename.downcase.end_with?(ext) }
+          html_extension?(filename)
         end
 
         # Process documents to SPA HTML