coradoc 1.1.7 → 2.0.2

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Sup < Base
+          def to_coradoc(node, state = {})
+            leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
+
+            content = treat_children_coradoc(node, state)
+
+            # Check if content is empty
+            return nil if content_empty?(content)
+
+            # Create CoreModel::InlineElement with format_type "superscript"
+            e = Coradoc::CoreModel::InlineElement.new(
+              format_type: 'superscript',
+              content: content
+            )
+            result = [leading_whitespace, e, trailing_whitespace].compact
+            result.length == 1 ? result.first : result
+          end
+
+          private
+
+          def content_empty?(content)
+            return true if content.nil?
+            return content.strip.empty? if content.is_a?(String)
+            return content.empty? if content.is_a?(Array)
+
+            false
+          end
+        end
+
+        register :sup, Sup.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Table < Base
+          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.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Td < Base
+          def to_coradoc(node, state = {})
+            node['id']
+            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)
+
+            # Use CoreModel::TableCell
+            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']
+            node['valign']
+            # Combine horizontal and vertical alignment
+            case align
+            when 'left' then 'left'
+            when 'center' then 'center'
+            when 'right' then 'right'
+            end
+            # Return alignment string (can be extended to include vertical)
+          end
+
+          # Extract text from content array
+          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.respond_to?(:content)
+                  item.content.to_s
+                else
+                  ''
+                end
+              else
+                item.to_s
+              end
+            end.join
+          end
+        end
+
+        register :td, Td.new
+        register :th, Td.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Text < Base
+          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::InlineElement.new(
+              format_type: 'text',
+              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.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Th < Td
+          def cellstyle(node)
+            # this is the header row
+            return '' if node.parent.previous_element.nil?
+
+            'h'
+          end
+        end
+
+        register :th, Th.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Tr < Base
+          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.element_children.all? {|child| child.name.to_sym == :th}
+            node.previous_element.nil?
+          end
+        end
+
+        register :tr, Tr.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Video < Base
+          def to_coradoc(node, _state = {})
+            src = node['src']
+            id = node['id']
+            title = extract_title(node)
+            options(node)
+
+            # Use Block with custom attributes to store video info
+            # CoreModel doesn't have a specific Video type, so we use Block
+            # with element_attributes to store video-specific data
+            Coradoc::CoreModel::Block.new(
+              element_type: 'video',
+              delimiter_type: 'video',
+              content: src,
+              title: title,
+              id: id,
+              width: node['width'],
+              height: node['height'],
+              element_attributes: {
+                autoplay: node['autoplay'],
+                loop: node['loop'],
+                controls: node['controls'],
+                poster: node['poster']
+              }.compact
+            )
+          end
+
+          def extract_title(node)
+            title = node.at('./track') || node.at('.//source')
+            return '' if title.nil?
+
+            title['label'] || title['srclang'] || ''
+          end
+
+          def options(node)
+            autoplay = node['autoplay']
+            loop_attr = node['loop']
+            controls = node['controls']
+            [autoplay, loop_attr, controls].compact
+          end
+        end
+
+        register :video, Video.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        # Autoload converter classes - they will register themselves when first accessed
+        autoload :Base, 'coradoc/html/input/converters/base'
+        autoload :Markup, 'coradoc/html/input/converters/markup'
+        autoload :A, 'coradoc/html/input/converters/a'
+        autoload :Aside, 'coradoc/html/input/converters/aside'
+        autoload :Audio, 'coradoc/html/input/converters/audio'
+        autoload :Blockquote, 'coradoc/html/input/converters/blockquote'
+        autoload :Br, 'coradoc/html/input/converters/br'
+        autoload :Bypass, 'coradoc/html/input/converters/bypass'
+        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 :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 :Ol, 'coradoc/html/input/converters/ol'
+        autoload :P, 'coradoc/html/input/converters/p'
+        autoload :PassThrough, 'coradoc/html/input/converters/pass_through'
+        autoload :Pre, 'coradoc/html/input/converters/pre'
+        autoload :Q, 'coradoc/html/input/converters/q'
+        autoload :Strong, 'coradoc/html/input/converters/strong'
+        autoload :Sup, 'coradoc/html/input/converters/sup'
+        autoload :Sub, 'coradoc/html/input/converters/sub'
+        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
+        def self.register(tag_name, converter)
+          @@converters ||= {}
+          @@converters[tag_name.to_sym] = converter
+        end
+
+        def self.unregister(tag_name)
+          @@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
+        end
+
+        def self.lookup(tag_name)
+          ensure_converters_loaded
+          converter = @@converters[tag_name.to_sym] || default_converter(tag_name)
+          converter = converter.new if converter.respond_to? :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)
+        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.config.unknown_tags.to_sym
+          when :pass_through
+            PassThrough.new
+          when :drop
+            Drop.new
+          when :bypass
+            Bypass.new
+          when :raise
+            raise Errors::UnknownTagError, "unknown tag: #{tag_name}"
+          else
+            raise Errors::InvalidConfigurationError,
+                  "unknown value #{Html.config.unknown_tags.inspect} for Coradoc::Input::Html.config.unknown_tags"
+          end
+        end
+      end
+    end
+  end
+end

data/coradoc-html/lib/coradoc/html/input/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Errors
+        # Base error class for HTML input errors
+        # Inherits from Coradoc::Error for unified error handling
+        class Error < Coradoc::Error
+        end
+
+        # Raised when an unknown HTML tag is encountered
+        class UnknownTagError < Error
+        end
+
+        # Raised when HTML input configuration is invalid
+        class InvalidConfigurationError < Error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      # HTML to CoreModel converter
+      #
+      # This class handles the conversion of HTML documents to CoreModel.
+      # It does NOT handle serialization to any specific output format.
+      # For serialization, use Coradoc.serialize(coremodel, to: :format)
+      #
+      # @example Basic usage - get CoreModel
+      #   coremodel = HtmlConverter.to_core_model(html_string)
+      #
+      # @example Serialize to AsciiDoc
+      #   coremodel = HtmlConverter.to_core_model(html_string)
+      #   adoc_text = Coradoc.serialize(coremodel, to: :asciidoc)
+      #
+      class HtmlConverter
+        # Convert HTML to CoreModel
+        #
+        # @param input [String, Nokogiri::XML::Document, Nokogiri::XML::Node] HTML input
+        # @param options [Hash] Conversion options
+        # @return [Coradoc::CoreModel::Base] CoreModel document
+        def self.to_core_model(input, options = {})
+          Input::Html.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
+              if plugin.respond_to?(:preprocess_html_tree)
+                track_time "Preprocessing document with #{plugin.name} plugin" do
+                  plugin.preprocess_html_tree
+                end
+              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|
+              next unless plugin.respond_to?(:postprocess_coremodel_tree)
+
+              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
+
+        # 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.respond_to?(: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
+
+        @track_time_indentation = 0
+        def self.track_time(task)
+          if Input::Html.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
+end