coradoc-html 1.1.18 → 1.1.19

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Q < Base
+        INSTANCE = new
+
+        def to_coradoc(node, state = {})
+          content = treat_children_coradoc(node, state)
+          cite = node['cite']
+
+          Coradoc::CoreModel::InlineElement.new(
+            format_type: 'quotation',
+            nested_elements: content,
+            content: extract_text_from_content(content),
+            target: cite
+          )
+        end
+      end
+
+      register :q, Q::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Strong < Markup
+        INSTANCE = new
+
+        def coradoc_format_type
+          'bold'
+        end
+
+        def markup_ancestor_tag_names
+          %w[strong b]
+        end
+      end
+
+      register :strong, Strong::INSTANCE
+      register :b,      Strong::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Sub < Base
+        INSTANCE = new
+        include PositionalFormatting
+
+        private
+
+        def element_class
+          Coradoc::CoreModel::SubscriptElement
+        end
+      end
+
+      register :sub, Sub::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Sup < Base
+        INSTANCE = new
+        include PositionalFormatting
+
+        private
+
+        def element_class
+          Coradoc::CoreModel::SuperscriptElement
+        end
+      end
+
+      register :sup, Sup::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Table < Base
+        INSTANCE = new
+
+        def to_coradoc(node, state = {})
+          id = node['id']
+          title = extract_title(node)
+          content = treat_children_coradoc(node, state)
+
+          # Apply frame and grid attributes if available
+          frame_attr = frame(node)
+          grid_attr = rules(node)
+
+          Coradoc::CoreModel::Table.new(
+            title: title,
+            rows: content,
+            id: id,
+            frame: frame_attr,
+            grid: grid_attr
+          )
+        end
+
+        def extract_title(node)
+          title = node.at('./caption')
+          return nil if title.nil?
+
+          title.text.strip
+        end
+
+        def frame(node)
+          case node['frame']
+          when 'void'
+            'none'
+          when 'hsides'
+            'topbot'
+          when 'vsides'
+            'sides'
+          when 'box', 'border'
+            'all'
+          end
+        end
+
+        def rules(node)
+          case node['rules']
+          when 'all'
+            'all'
+          when 'rows'
+            'rows'
+          when 'cols'
+            'cols'
+          when 'none'
+            'none'
+          end
+        end
+      end
+
+      register :table, Table::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Td < Base
+        INSTANCE = new
+
+        def to_coradoc(node, state = {})
+          colspan = node['colspan']&.to_i
+          rowspan = node['rowspan']&.to_i
+          alignment = extract_alignment(node)
+
+          singlepara = node.elements.size == 1 && node.elements.first.name == 'p'
+          state[:tdsinglepara] = singlepara if singlepara
+
+          content = treat_children_coradoc(node, state)
+
+          Coradoc::CoreModel::TableCell.new(
+            content: extract_text_from_content(content),
+            alignment: alignment,
+            colspan: colspan && colspan > 1 ? colspan : nil,
+            rowspan: rowspan && rowspan > 1 ? rowspan : nil,
+            header: node.name == 'th'
+          )
+        end
+
+        def extract_alignment(node)
+          align = node['align']
+          case align
+          when 'left' then 'left'
+          when 'center' then 'center'
+          when 'right' then 'right'
+          end
+        end
+      end
+
+      register :td, Td::INSTANCE
+      register :th, Td::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Text < Base
+        INSTANCE = new
+
+        def to_coradoc(node, state = {})
+          return treat_empty(node, state) if node.text.strip.empty?
+
+          # HTML cleanup is performed in the converter layer
+          cleaned_content = cleanup_html_text(node.text)
+
+          # Return as CoreModel::InlineElement with format_type "text"
+          Coradoc::CoreModel::TextElement.new(
+            content: cleaned_content
+          )
+        end
+
+        private
+
+        def treat_empty(node, state)
+          parent = node.parent.name.to_sym
+          if %i[ol ul].include?(parent) # Otherwise the indentation is broken
+            nil
+          elsif state[:tdsinglepara]
+            nil
+          elsif node.text == ' ' # Regular whitespace text node
+            ' '
+          else
+            nil
+          end
+        end
+
+        # HTML-to-CoreModel text cleanup
+        def cleanup_html_text(text)
+          text = preserve_nbsp(text)
+          text = remove_border_newlines(text)
+          text = remove_inner_newlines(text)
+          escape_links(text)
+        end
+
+        def preserve_nbsp(text)
+          text.gsub("\u00A0", '&nbsp;')
+        end
+
+        def escape_links(text)
+          text.gsub(/<<([^ ][^>]*)>>/, '\\<<\\1>>')
+        end
+
+        def remove_border_newlines(text)
+          text.gsub(/\A\n+/, '').gsub(/\n+\z/, '')
+        end
+
+        def remove_inner_newlines(text)
+          # Convert newlines/tabs to spaces and squeeze multiple spaces
+          # Preserve single leading/trailing space for inline contexts
+          text.tr("\n\t", ' ').squeeze(' ')
+        end
+      end
+
+      register :text, Text::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Tr < Base
+        INSTANCE = new
+
+        def to_coradoc(node, state = {})
+          content = treat_children_coradoc(node, state)
+          header = table_header_row?(node)
+          # Use CoreModel::TableRow with cells (not columns)
+          Coradoc::CoreModel::TableRow.new(
+            cells: content,
+            header: header
+          )
+        end
+
+        def table_header_row?(node)
+          node.previous_element.nil?
+        end
+      end
+
+      register :tr, Tr::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Video < MediaBase
+        INSTANCE = new
+
+        private
+
+        def semantic_type
+          :video
+        end
+
+        def build_attributes(node)
+          base_attributes(node).merge(
+            poster: node['poster'],
+            width: node['width'],
+            height: node['height']
+          ).compact
+        end
+      end
+
+      register :video, Video::INSTANCE
+    end
+  end
+end

data/lib/coradoc/html/converters.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      CONVERTERS = {
+        Base: 'coradoc/html/converters/base',
+        Markup: 'coradoc/html/converters/markup',
+        A: 'coradoc/html/converters/a',
+        Aside: 'coradoc/html/converters/aside',
+        Audio: 'coradoc/html/converters/audio',
+        Blockquote: 'coradoc/html/converters/blockquote',
+        Br: 'coradoc/html/converters/br',
+        Bypass: 'coradoc/html/converters/bypass',
+        Code: 'coradoc/html/converters/code',
+        Div: 'coradoc/html/converters/div',
+        Dl: 'coradoc/html/converters/dl',
+        Skip: 'coradoc/html/converters/drop',
+        Em: 'coradoc/html/converters/em',
+        Figure: 'coradoc/html/converters/figure',
+        H: 'coradoc/html/converters/h',
+        Head: 'coradoc/html/converters/head',
+        Hr: 'coradoc/html/converters/hr',
+        Img: 'coradoc/html/converters/img',
+        Li: 'coradoc/html/converters/li',
+        Mark: 'coradoc/html/converters/mark',
+        Math: 'coradoc/html/converters/math',
+        MediaBase: 'coradoc/html/converters/media_base',
+        Ol: 'coradoc/html/converters/ol',
+        P: 'coradoc/html/converters/p',
+        PassThrough: 'coradoc/html/converters/pass_through',
+        PositionalFormatting: 'coradoc/html/converters/positional_formatting',
+        Pre: 'coradoc/html/converters/pre',
+        Q: 'coradoc/html/converters/q',
+        Strong: 'coradoc/html/converters/strong',
+        Sup: 'coradoc/html/converters/sup',
+        Sub: 'coradoc/html/converters/sub',
+        Table: 'coradoc/html/converters/table',
+        Td: 'coradoc/html/converters/td',
+        Text: 'coradoc/html/converters/text',
+        Tr: 'coradoc/html/converters/tr',
+        Video: 'coradoc/html/converters/video'
+      }.freeze
+      private_constant :CONVERTERS
+
+      CONVERTERS.each do |name, path|
+        autoload name, path
+      end
+
+      @converters = {}
+      @converters_loaded = false
+
+      def self.register(tag_name, converter)
+        @converters[tag_name.to_sym] = converter
+      end
+
+      def self.unregister(tag_name)
+        @converters.delete(tag_name.to_sym)
+      end
+
+      def self.ensure_converters_loaded
+        return if @converters_loaded
+
+        @converters_loaded = true
+        CONVERTERS.each_key { |name| const_get(name) }
+      end
+
+      def self.lookup(tag_name)
+        ensure_converters_loaded
+        @converters[tag_name.to_sym] || default_converter(tag_name)
+      end
+
+      def self.process_coradoc(node, state)
+        node = node.to_a if node.is_a? Nokogiri::XML::NodeSet
+        return node.map { |i| process_coradoc(i, state) } if node.is_a? Array
+
+        plugins = state[:plugin_instances] || {}
+        process = proc { lookup(node.name).to_coradoc(node, state) }
+        plugins.each do |i|
+          prev_process = process
+          process = proc { i.html_tree_run_hooks(node, state, &prev_process) }
+        end
+        process.call(node, state)
+      end
+
+      def self.default_converter(tag_name)
+        case Html.input_config.unknown_tags.to_sym
+        when :pass_through
+          PassThrough::INSTANCE
+        when :drop
+          Skip::INSTANCE
+        when :bypass
+          Bypass::INSTANCE
+        when :raise
+          raise Errors::UnknownTagError, "unknown tag: #{tag_name}"
+        else
+          raise Errors::InvalidConfigurationError,
+                "unknown value #{Html.input_config.unknown_tags.inspect} " \
+                  'for Coradoc::Html.input_config.unknown_tags'
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/drop/drop_factory.rb

@@ -33,6 +33,20 @@ module Coradoc
           drop&.new(model)&.template_type
         end
 
+        # Walk the Drop namespace and trigger each declared autoload so the
+        # drop class body evaluates and self-registers. Called eagerly from
+        # drop.rb after autoloads are declared.
+        EAGER_LOAD_ORDER = %i[Base DropFactory AnnotationDrop BlockDrop ListBlockDrop ListItemDrop
+                              TableDrop TableRowDrop TableCellDrop ImageDrop InlineElementDrop RawInlineElementDrop
+                              BibliographyEntryDrop BibliographyDrop TocEntryDrop TocDrop DefinitionItemDrop
+                              DefinitionListDrop TermDrop FootnoteDrop TextContentDrop DocumentDrop].freeze
+        private_constant :EAGER_LOAD_ORDER
+
+        def self.eager_load!
+          EAGER_LOAD_ORDER.each { |sym| Drop.const_get(sym) }
+          true
+        end
+
         class << self
           private
 
@@ -48,25 +62,3 @@ module Coradoc
     end
   end
 end
-
-# Load all drops — each self-registers with DropFactory.
-# Registration order doesn't matter (sorted by ancestor depth).
-require_relative 'annotation_drop'
-require_relative 'block_drop'
-require_relative 'list_block_drop'
-require_relative 'list_item_drop'
-require_relative 'table_drop'
-require_relative 'table_row_drop'
-require_relative 'table_cell_drop'
-require_relative 'image_drop'
-require_relative 'inline_element_drop'
-require_relative 'bibliography_entry_drop'
-require_relative 'bibliography_drop'
-require_relative 'toc_entry_drop'
-require_relative 'toc_drop'
-require_relative 'definition_item_drop'
-require_relative 'definition_list_drop'
-require_relative 'term_drop'
-require_relative 'footnote_drop'
-require_relative 'text_content_drop'
-require_relative 'document_drop'

data/lib/coradoc/html/drop/inline_element_drop.rb

@@ -27,11 +27,9 @@ module Coradoc
         end
 
         def css_class
-          case format_type
-          when 'stem' then 'stem'
-          when 'term' then 'term'
-          when 'span' then @model.metadata('class')
-          end
+          return @model.metadata('class') if format_type == 'span'
+
+          TagMapping.css_class_for(format_type)
         end
 
         def term_ref

data/lib/coradoc/html/drop/raw_inline_element_drop.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      # Drop for CoreModel::RawInlineElement.
+      #
+      # Passthrough content is raw output-format markup (typically HTML)
+      # that the source author explicitly marked as "emit verbatim." The
+      # generic InlineElementDrop escapes content; this subclass skips
+      # escaping so the rendered output mirrors the author's intent.
+      #
+      # The Liquid template is shared with InlineElementDrop — only the
+      # data preparation differs. InlineElementDrop is autoloaded by the
+      # Drop namespace shell (drop.rb) and is guaranteed to load before
+      # this class via DropFactory.eager_load! ordering.
+      class RawInlineElementDrop < InlineElementDrop
+        def text
+          extract_text(@model.content).to_s
+        end
+
+        def template_type
+          'inline_element'
+        end
+      end
+
+      DropFactory.register(CoreModel::RawInlineElement, RawInlineElementDrop)
+    end
+  end
+end

data/lib/coradoc/html/drop.rb

@@ -1,18 +1,40 @@
 # frozen_string_literal: true
 
-# Drop namespace — manages Liquid drop layer for template rendering.
+# Drop namespace — Liquid drop layer for template rendering.
 #
-# Loading order matters: Base must load before DropFactory, and all
-# concrete drops must load after DropFactory (they self-register).
-# Each drop calls DropFactory.register at load time.
+# Each drop class is autoloaded from its own file (one class per file,
+# mirroring the mirror/ReverseBuilder pattern). Eager loading is delegated
+# to DropFactory.eager_load!, which triggers each autoload in dependency
+# order so drops self-register with DropFactory at load time.
 module Coradoc
   module Html
     module Drop
+      autoload :Base, "#{__dir__}/drop/base"
+      autoload :DropFactory, "#{__dir__}/drop/drop_factory"
+      autoload :AnnotationDrop, "#{__dir__}/drop/annotation_drop"
+      autoload :BlockDrop, "#{__dir__}/drop/block_drop"
+      autoload :ListBlockDrop, "#{__dir__}/drop/list_block_drop"
+      autoload :ListItemDrop, "#{__dir__}/drop/list_item_drop"
+      autoload :TableDrop, "#{__dir__}/drop/table_drop"
+      autoload :TableRowDrop, "#{__dir__}/drop/table_row_drop"
+      autoload :TableCellDrop, "#{__dir__}/drop/table_cell_drop"
+      autoload :ImageDrop, "#{__dir__}/drop/image_drop"
+      # InlineElementDrop must load before RawInlineElementDrop (subclass).
+      autoload :InlineElementDrop, "#{__dir__}/drop/inline_element_drop"
+      autoload :RawInlineElementDrop, "#{__dir__}/drop/raw_inline_element_drop"
+      autoload :BibliographyEntryDrop, "#{__dir__}/drop/bibliography_entry_drop"
+      autoload :BibliographyDrop, "#{__dir__}/drop/bibliography_drop"
+      autoload :TocEntryDrop, "#{__dir__}/drop/toc_entry_drop"
+      autoload :TocDrop, "#{__dir__}/drop/toc_drop"
+      autoload :DefinitionItemDrop, "#{__dir__}/drop/definition_item_drop"
+      autoload :DefinitionListDrop, "#{__dir__}/drop/definition_list_drop"
+      autoload :TermDrop, "#{__dir__}/drop/term_drop"
+      autoload :FootnoteDrop, "#{__dir__}/drop/footnote_drop"
+      autoload :TextContentDrop, "#{__dir__}/drop/text_content_drop"
+      autoload :DocumentDrop, "#{__dir__}/drop/document_drop"
     end
   end
 end
 
-# Base must load first (DropFactory depends on it)
-require_relative 'drop/base'
-# DropFactory loads next
-require_relative 'drop/drop_factory'
+# Trigger eager load so every drop class body evaluates and self-registers.
+Coradoc::Html::Drop::DropFactory.eager_load!

data/lib/coradoc/html/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Errors
+      class Error < Coradoc::Error; end
+      class UnknownTagError < Error; end
+      class InvalidConfigurationError < Error; end
+    end
+  end
+end

data/lib/coradoc/html/html_converter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    class HtmlConverter
+      def self.to_core_model(input, options = {})
+        Html.input_config.with(options) do
+          plugin_instances = prepare_plugin_instances(options)
+
+          root = track_time 'Loading input HTML document' do
+            case input
+            when String
+              Nokogiri::HTML(input).root
+            when Nokogiri::XML::Document
+              input.root
+            when Nokogiri::XML::Node
+              input
+            end
+          end
+
+          return nil unless root
+
+          plugin_instances.each do |plugin|
+            plugin.html_tree = root
+            track_time "Preprocessing document with #{plugin.name} plugin" do
+              plugin.preprocess_html_tree
+            end
+            root = plugin.html_tree
+          end
+
+          coremodel = track_time 'Converting input document tree to CoreModel' do
+            Converters.process_coradoc(
+              root,
+              plugin_instances: plugin_instances
+            )
+          end
+
+          coremodel = track_time 'Post-process CoreModel tree' do
+            Postprocessor.process(coremodel)
+          end
+
+          plugin_instances.each do |plugin|
+            plugin.coremodel_tree = coremodel
+            track_time "Postprocessing CoreModel tree with #{plugin.name} plugin" do
+              plugin.postprocess_coremodel_tree
+            end
+            coremodel = plugin.coremodel_tree
+          end
+
+          options[:plugin_instances] = plugin_instances unless options.frozen?
+
+          coremodel
+        end
+      end
+
+      def self.prepare_plugin_instances(options)
+        options[:plugin_instances] || Html.input_config.plugins.map(&:new)
+      end
+
+      @track_time_indentation = 0
+      def self.track_time(task)
+        if Html.input_config.track_time
+          warn ('  ' * @track_time_indentation) + "* #{task} is starting..."
+          @track_time_indentation += 1
+          t0 = Time.now
+          ret = yield
+          time_elapsed = Time.now - t0
+          @track_time_indentation -= 1
+          warn ('  ' * @track_time_indentation) +
+               "* #{task} took #{time_elapsed.round(3)} seconds"
+          ret
+        else
+          yield
+        end
+      end
+    end
+  end
+end