coradoc-html 1.1.7 → 1.1.14

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class InlineElementDrop < Base
+        FORMAT_TAG_MAP = {
+          'bold' => 'strong',
+          'italic' => 'em',
+          'monospace' => 'code',
+          'superscript' => 'sup',
+          'subscript' => 'sub',
+          'underline' => 'u',
+          'strikethrough' => 'del',
+          'highlight' => 'mark',
+          'quotation' => 'q',
+          'small' => 'small',
+          'stem' => 'code'
+        }.freeze
+
+        def format_type
+          @model.resolve_format_type
+        end
+
+        def html_tag
+          case format_type
+          when 'link', 'xref' then 'a'
+          when 'footnote' then 'sup'
+          when 'span', 'term' then 'span'
+          else FORMAT_TAG_MAP[format_type]
+          end
+        end
+
+        def href
+          case format_type
+          when 'link'
+            @model.target || @model.metadata('href') || '#'
+          when 'xref'
+            target = @model.target || @model.metadata('href') || ''
+            "##{target}"
+          end
+        end
+
+        def text
+          Escape.escape_html(extract_text(@model.content))
+        end
+
+        def css_class
+          case format_type
+          when 'stem' then 'stem'
+          when 'term' then 'term'
+          when 'span' then @model.metadata('class')
+          end
+        end
+
+        def term_ref
+          @model.content.to_s if format_type == 'term'
+        end
+      end
+
+      DropFactory.register(CoreModel::InlineElement, InlineElementDrop)
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class ListBlockDrop < Base
+        def html_tag
+          case @model.marker_type
+          when 'ordered' then 'ol'
+          when 'definition' then 'dl'
+          else 'ul'
+          end
+        end
+
+        def items
+          children_to_liquid(@model.items)
+        end
+      end
+
+      DropFactory.register(CoreModel::ListBlock, ListBlockDrop)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class ListItemDrop < Base
+        def content
+          content_to_liquid(@model.content)
+        end
+
+        def nested_list
+          child = @model.nested_list
+          DropFactory.create(child) if child
+        end
+      end
+
+      DropFactory.register(CoreModel::ListItem, ListItemDrop)
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class TableCellDrop < Base
+        def header?
+          @model.header == true
+        end
+
+        def html_tag
+          header? ? 'th' : 'td'
+        end
+
+        def colspan
+          @model.colspan&.to_s
+        end
+
+        def rowspan
+          @model.rowspan&.to_s
+        end
+
+        def style
+          "text-align: #{@model.alignment}" if @model.alignment
+        end
+
+        def content
+          content_to_liquid(@model.renderable_content)
+        end
+      end
+
+      DropFactory.register(CoreModel::TableCell, TableCellDrop)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class TableDrop < Base
+        def rows
+          children_to_liquid(@model.rows)
+        end
+      end
+
+      DropFactory.register(CoreModel::Table, TableDrop)
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class TableRowDrop < Base
+        def header?
+          @model.header == true
+        end
+
+        def html_tag
+          'tr'
+        end
+
+        def cells
+          children_to_liquid(@model.cells)
+        end
+      end
+
+      DropFactory.register(CoreModel::TableRow, TableRowDrop)
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class TermDrop < Base
+        def text
+          Escape.escape_html(@model.text.to_s)
+        end
+
+        def term_ref
+          @model.text.to_s
+        end
+
+        def css_class
+          t = @model.type || 'term'
+          "term term-#{t}"
+        end
+      end
+
+      DropFactory.register(CoreModel::Term, TermDrop)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class TextContentDrop < Base
+        def text
+          Escape.escape_html(@model.text.to_s)
+        end
+      end
+
+      DropFactory.register(CoreModel::TextContent, TextContentDrop)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class TocDrop < Base
+        def entries
+          children_to_liquid(@model.entries)
+        end
+      end
+
+      DropFactory.register(CoreModel::Toc, TocDrop)
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class TocEntryDrop < Base
+        def title
+          TitleText.escape(@model.title)
+        end
+
+        def number
+          @model.number
+        end
+
+        def level
+          @model.level
+        end
+
+        def children
+          children_to_liquid(@model.children)
+        end
+
+        def numbered_title
+          n = number
+          n ? "#{n}. #{title}" : title
+        end
+      end
+
+      DropFactory.register(CoreModel::TocEntry, TocEntryDrop)
+    end
+  end
+end

data/lib/coradoc/html/drop.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Drop namespace — manages 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.
+module Coradoc
+  module Html
+    module Drop
+    end
+  end
+end
+
+# Base must load first (DropFactory depends on it)
+require 'coradoc/html/drop/base'
+# DropFactory loads next
+require 'coradoc/html/drop/drop_factory'

data/lib/coradoc/html/escape.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'json'
+
+module Coradoc
+  module Html
+    module Escape
+      module_function
+
+      def escape_html(text)
+        CGI.escapeHTML(text.to_s)
+      end
+
+      def escape_attr(value)
+        value.to_s
+             .gsub('&', '&')
+             .gsub('"', '"')
+             .gsub('<', '&lt;')
+             .gsub('>', '&gt;')
+      end
+
+      def safe_json(data)
+        json = data.is_a?(String) ? data : JSON.generate(data)
+        json.gsub('</script', '<\\/script')
+      end
+    end
+  end
+end

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

@@ -7,18 +7,10 @@ module Coradoc
         # Pre-compiled regexes for performance
         INNER_WHITESPACE_REGEX_1 = /\n stem:\[/
         INNER_WHITESPACE_REGEX_2 = /(stem:\[([^\]]|\\\])*\])\n(?=\S)/
-        INNER_WHITESPACE_REGEX_3 = /(stem:\[([^\]]|\\\])*\])\s+(?=[\^-])/
         NEWLINES_REGEX = /\n{3,}/
         LEADING_NEWLINE_REGEX = /\A\n+/
         WHITESPACE_REGEX = /[ \t\r\n]+/
         TRAILING_WHITESPACE_REGEX = /[ \t\r\n]+\z/
-        MULTIPLE_WHITESPACE_REGEX = /[ \t]{2,}/
-        TAG_BORDER_REGEXES = {
-          asterisk: /\s?\*{2,}/,
-          underscore: /\s?_{2,}/,
-          tilde: /\s?~{2,}/,
-          bracket: /\s?\[.*?\]\s?/
-        }.freeze
 
         def tidy(string)
           return string.transform_values { |i| tidy(i) } if string.is_a? Hash
@@ -74,23 +66,7 @@ module Coradoc
           result
         end
 
-        # Find non-asterisk content that is enclosed by two or
-        # more asterisks. Ensure that only one whitespace occurs
-        # in the border area.
-        # Same for underscores and brackets.
         def clean_tag_borders(string)
-          # result = string.gsub(/\s?\*{2,}.*?\*{2,}\s?/) do |match|
-          # preserve_border_whitespaces(match, default_border: Coradoc::Input::HTML.config.tag_border) do
-          #   match.strip.sub("** ", "**").sub(" **", "**")
-          # end
-          # end
-
-          # result = string.gsub(/\s?_{2,}.*?_{2,}\s?/) do |match|
-          #   preserve_border_whitespaces(match, default_border: Coradoc::Input::HTML.config.tag_border) do
-          #     match.strip.sub("__ ", "__").sub(" __", "__")
-          #   end
-          # end
-
           result = string.gsub(/\s?~{2,}.*?~{2,}\s?/) do |match|
             preserve_border_whitespaces(
               match,
@@ -111,29 +87,24 @@ module Coradoc
           string.gsub(/(\*\*|~~|__)\s([.!?'"])/, '\\1\\2')
         end
 
-        # preprocesses HTML, rather than postprocessing it
         def preprocess_word_html(string)
           clean_headings(scrub_whitespace(string.dup))
         end
 
         def scrub_whitespace(string)
-          string.gsub!(/ | |\u00a0/i, ' ') # HTML encoded spaces
-          string = Coradoc.strip_unicode(string) # Strip document-level leading and trailing whitespace
-          string.gsub!(/( +)$/, ' ') # line trailing whitespace
-          string.gsub!("\n\n\n\n", "\n\n") # Quadruple line breaks
-          # string.delete!('?| ')               # Unicode non-breaking spaces, injected as tabs
+          string.gsub!(/ | | /i, ' ')
+          string = Coradoc.strip_unicode(string)
+          string.gsub!(/( +)$/, ' ')
+          string.gsub!("\n\n\n\n", "\n\n")
           string
         end
 
-        # following added by me
         def clean_headings(string)
           string.gsub!(%r{<h([1-9])[^>]*></h\1>}, ' ')
-          # I don't know why Libre Office is inserting them, but they need to go
           string.gsub!(
             %r{<h([1-9])[^>]* style="vertical-align: super;[^>]*>(.+?)</h\1>},
             '<sup>\\2</sup>'
           )
-          # I absolutely don't know why Libre Office is rendering superscripts as h1
           string
         end
 

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

@@ -53,11 +53,12 @@ module Coradoc
         end
 
         def self.declare_option(option)
+          attr_accessor option
+
+          original_reader = instance_method(option)
           define_method(option) do
-            @inline_options[option] || instance_variable_get(:"@#{option}")
+            @inline_options[option] || original_reader.bind_call(self)
           end
-
-          attr_writer option
         end
 
         declare_option :unknown_tags

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

@@ -7,6 +7,8 @@ module Coradoc
     module Html
       module Converters
         class A < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
             # Use treat_children_coradoc to get CoreModel elements
             content = treat_children_coradoc(node, state)
@@ -31,14 +33,8 @@ module Coradoc
             # For cross-references
             if href.to_s.start_with?('#')
               ref_id = href.sub(/^#/, '').gsub(/\s/, '').gsub(/__+/, '_')
-              # Convert content to string
-              content_str = if content.is_a?(Array)
-                              content.map { |c| c.is_a?(Coradoc::CoreModel::Base) ? c.content : c.to_s }.join
-                            else
-                              content.to_s
-                            end
-              return Coradoc::CoreModel::InlineElement.new(
-                format_type: 'xref',
+              content_str = extract_text_from_content(content)
+              return Coradoc::CoreModel::CrossReferenceElement.new(
                 target: ref_id,
                 content: content_str.strip.empty? ? nil : content_str.strip
               )
@@ -50,25 +46,18 @@ module Coradoc
             ambigous_characters = /[\w.?&#=%;\[\u{ff}-\u{10ffff}]/
             right_constrain = textnode_after_start_with?(node, ambigous_characters)
 
-            # Convert content to string for the link
-            content_str = if content.is_a?(Array)
-                            content.map { |c| c.is_a?(Coradoc::CoreModel::Base) && c.content ? c.content : c.to_s }.join
-                          else
-                            content.to_s
-                          end
+            content_str = extract_text_from_content(content)
 
             out = []
             # Add leading space if needed
             if textnode_before_end_with?(node, ambigous_characters)
-              out << Coradoc::CoreModel::InlineElement.new(
-                format_type: 'text',
+              out << Coradoc::CoreModel::TextElement.new(
                 content: ' '
               )
             end
 
             # Create link element
-            link = Coradoc::CoreModel::InlineElement.new(
-              format_type: 'link',
+            link = Coradoc::CoreModel::LinkElement.new(
               target: href,
               content: content_str.strip,
               metadata: {
@@ -83,7 +72,7 @@ module Coradoc
           end
         end
 
-        register :a, A.new
+        register :a, A::INSTANCE
       end
     end
   end

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

@@ -5,18 +5,17 @@ module Coradoc
     module Html
       module Converters
         class Aside < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
             content = treat_children_coradoc(node, state)
-            # Use AnnotationBlock with annotation_type: "sidebar" for aside elements
-            Coradoc::CoreModel::AnnotationBlock.new(
-              annotation_type: 'sidebar',
-              block_semantic_type: :sidebar,
+            Coradoc::CoreModel::SidebarBlock.new(
               children: content
             )
           end
         end
 
-        register :aside, Aside.new
+        register :aside, Aside::INSTANCE
       end
     end
   end

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

@@ -4,46 +4,17 @@ module Coradoc
   module Input
     module Html
       module Converters
-        class Audio < Base
-          def to_coradoc(node, _state = {})
-            src = node['src']
-            id = node['id']
-            title = extract_title(node)
-            options(node)
+        class Audio < MediaBase
+          INSTANCE = new
 
-            # Use Block with custom attributes to store audio info
-            # CoreModel doesn't have a specific Audio type, so we use Block
-            # with element_attributes to store audio-specific data
-            Coradoc::CoreModel::Block.new(
-              element_type: 'audio',
-              block_semantic_type: :audio,
-              content: src,
-              title: title,
-              id: id,
-              element_attributes: {
-                autoplay: node['autoplay'],
-                loop: node['loop'],
-                controls: node['controls']
-              }.compact
-            )
-          end
-
-          def extract_title(node)
-            title = node.at('./track') || node.at('.//source')
-            return '' if title.nil?
-
-            title['label'] || title['srclang'] || ''
-          end
+          private
 
-          def options(node)
-            autoplay = node['autoplay']
-            loop_attr = node['loop']
-            controls = node['controls']
-            [autoplay, loop_attr, controls].compact
+          def semantic_type
+            :audio
           end
         end
 
-        register :audio, Audio.new
+        register :audio, Audio::INSTANCE
       end
     end
   end

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

@@ -5,24 +5,6 @@ module Coradoc
     module Html
       module Converters
         class Base
-          # Default implementation to convert a given Nokogiri node
-          # to a CoreModel type.
-          # Can be overriden by subclasses.
-          def convert(node, state = {})
-            to_coradoc(node, state)
-          end
-
-          # NOTE: treat_children won't run plugin hooks
-          def treat_children(node, state)
-            node.children.map do |child|
-              treat(child, state)
-            end
-          end
-
-          def treat(node, state)
-            Converters.process(node, state)
-          end
-
           def treat_children_coradoc(node, state)
             results = node.children.map do |child|
               treat_coradoc(child, state)
@@ -44,15 +26,15 @@ module Coradoc
           def node_has_ancestor?(node, name)
             case name
             when String
-              node.ancestors.map(&:name).include?(name)
+              node.ancestors(name).any?
             when Array
-              (node.ancestors.map(&:name) & name).any?
+              name.any? { |n| node.ancestors(n).any? }
             end
           end
 
           def textnode_before_end_with?(node, str)
-            return nil unless [String, Regexp].include?(str.class)
-            return nil if str.is_a?(String) && str.empty?
+            return false unless [String, Regexp].include?(str.class)
+            return false if str.is_a?(String) && str.empty?
 
             str = /#{Regexp.escape(str)}/ if str.is_a?(String)
             str = /(?:#{str})\z/
@@ -62,8 +44,8 @@ module Coradoc
           end
 
           def textnode_after_start_with?(node, str)
-            return nil unless [String, Regexp].include?(str.class)
-            return nil if str.is_a?(String) && str.empty?
+            return false unless [String, Regexp].include?(str.class)
+            return false if str.is_a?(String) && str.empty?
 
             str = /#{Regexp.escape(str)}/ if str.is_a?(String)
             str = /\A(?:#{str})/
@@ -105,9 +87,29 @@ module Coradoc
               after.text[0]&.match?(/\w|,|;|"|\.\?!/)
           end
 
-          # Helper to escape text content
-          def escape_text(text)
-            text.to_s.gsub(/[<>&]/, '<' => '&lt;', '>' => '&gt;', '&' => '&amp;')
+          # Extract plain text from a mixed content array.
+          # Handles String, InlineElement (via .content), and other
+          # CoreModel::Base (via .content or .title).
+          def extract_text_from_content(content)
+            return content if content.is_a?(String)
+            return '' if content.nil?
+
+            content.map do |item|
+              case item
+              when String
+                item
+              when Coradoc::CoreModel::InlineElement
+                item.content.to_s
+              when Coradoc::CoreModel::Base
+                if item.content
+                  item.content.to_s
+                else
+                  ''
+                end
+              else
+                item.to_s
+              end
+            end.join
           end
         end
       end

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

@@ -5,20 +5,22 @@ module Coradoc
     module Html
       module Converters
         class Blockquote < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
             id = node['id']
             cite = node['cite']
             content = treat_children_coradoc(node, state)
 
             Coradoc::CoreModel::QuoteBlock.new(
-              content: content,
+              children: content,
               id: id,
               attribution: cite
             )
           end
         end
 
-        register :blockquote, Blockquote.new
+        register :blockquote, Blockquote::INSTANCE
       end
     end
   end