coradoc-html 1.1.18 → 1.1.19

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Ol < Base
-          INSTANCE = new
-
-          def to_coradoc(node, state = {})
-            id = node['id']
-            items = treat_children_coradoc(node, state)
-
-            marker_type = get_list_type(node, state)
-
-            Coradoc::CoreModel::ListBlock.new(
-              marker_type: marker_type,
-              items: items,
-              id: id,
-              start: node['start']&.to_i
-            )
-          end
-
-          def get_list_type(node, _state)
-            case node.name
-            when 'ol'
-              'ordered'
-            when 'ul'
-              'unordered'
-            when 'dir'
-              'unordered'
-            else
-              'unordered'
-            end
-          end
-        end
-
-        register :ol,  Ol::INSTANCE
-        register :ul,  Ol::INSTANCE
-        register :dir, Ol::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class P < Base
-          INSTANCE = new
-
-          def to_coradoc(node, state = {})
-            id = node['id']
-            content = treat_children_coradoc(node, state)
-
-            content = strip_fullwidth_spaces(content)
-
-            Coradoc::CoreModel::ParagraphBlock.new(
-              children: content,
-              id: id
-            )
-          end
-
-          private
-
-          def strip_fullwidth_spaces(content)
-            return content unless content.is_a?(Array)
-
-            content.each do |item|
-              next unless item.is_a?(Coradoc::CoreModel::InlineElement)
-              next unless item.content.is_a?(String)
-
-              item.content = item.content.gsub(/\A　+|　+\z/, '')
-            end
-
-            strip_edge_whitespace(content)
-            reject_empty_elements(content)
-          end
-
-          def strip_edge_whitespace(content)
-            first = content.find { |item| text_element?(item) }
-            strip_left(first) if first
-
-            last = content.reverse.find { |item| text_element?(item) }
-            strip_right(last) if last
-          end
-
-          def strip_left(item)
-            case item
-            when Coradoc::CoreModel::InlineElement
-              item.content = item.content.lstrip if item.content.is_a?(String)
-            when String
-              item.replace(item.lstrip)
-            end
-          end
-
-          def strip_right(item)
-            case item
-            when Coradoc::CoreModel::InlineElement
-              item.content = item.content.rstrip if item.content.is_a?(String)
-            when String
-              item.replace(item.rstrip)
-            end
-          end
-
-          def text_element?(item)
-            item.is_a?(Coradoc::CoreModel::InlineElement) || item.is_a?(String)
-          end
-
-          def reject_empty_elements(content)
-            content.reject do |item|
-              if item.is_a?(Coradoc::CoreModel::InlineElement)
-                item.content.to_s.empty? && !has_nested_content?(item)
-              elsif item.is_a?(String)
-                item.empty?
-              else
-                false
-              end
-            end
-          end
-
-          def has_nested_content?(item)
-            item.is_a?(Coradoc::CoreModel::InlineElement) &&
-              item.nested_elements && !item.nested_elements.empty?
-          end
-        end
-
-        register :p, P::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class PassThrough < Base
-          INSTANCE = new
-
-          def to_coradoc(node, _state = {})
-            node.to_s
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        # Shared logic for superscript/subscript converters.
-        #
-        # Subclasses must implement `element_class` returning the
-        # CoreModel class (e.g., SuperscriptElement, SubscriptElement).
-        module PositionalFormatting
-          def to_coradoc(node, state = {})
-            leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
-
-            content = treat_children_coradoc(node, state)
-
-            return nil if content_empty?(content)
-
-            e = element_class.new(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
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Pre < Base
-          INSTANCE = new
-
-          def to_coradoc(node, _state = {})
-            id = node['id']
-            lang = language(node)
-            content = extract_text_content(node)
-
-            if lang
-              Coradoc::CoreModel::SourceBlock.new(
-                content: content,
-                id: id,
-                language: lang
-              )
-            else
-              Coradoc::CoreModel::LiteralBlock.new(
-                content: content,
-                id: id
-              )
-            end
-          end
-
-          private
-
-          def extract_text_content(node)
-            # Get text content from pre node
-            node.text
-          end
-
-          def language(node)
-            lang = language_from_highlight_class(node)
-            lang || language_from_confluence_class(node)
-          end
-
-          def language_from_highlight_class(node)
-            node.parent['class'].to_s[/highlight-([a-zA-Z0-9]+)/, 1]
-          end
-
-          def language_from_confluence_class(node)
-            class_str = node['class'].to_s
-            return nil unless class_str.include?('brush:')
-
-            # Extract language from brush: language; pattern
-            match = class_str.match(/brush:\s*([^;]+);/)
-            match ? match[1].strip : nil
-          end
-        end
-
-        register :pre, Pre::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    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
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    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
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    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
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    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
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    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
-end

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    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
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    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
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    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
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    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
-end

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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        # Autoload converter classes — they self-register when loaded.
-        # Adding a new converter requires only adding one entry here.
-        CONVERTERS = {
-          Base: 'coradoc/html/input/converters/base',
-          Markup: 'coradoc/html/input/converters/markup',
-          A: 'coradoc/html/input/converters/a',
-          Aside: 'coradoc/html/input/converters/aside',
-          Audio: 'coradoc/html/input/converters/audio',
-          Blockquote: 'coradoc/html/input/converters/blockquote',
-          Br: 'coradoc/html/input/converters/br',
-          Bypass: 'coradoc/html/input/converters/bypass',
-          Code: 'coradoc/html/input/converters/code',
-          Div: 'coradoc/html/input/converters/div',
-          Dl: 'coradoc/html/input/converters/dl',
-          Skip: 'coradoc/html/input/converters/drop',
-          Em: 'coradoc/html/input/converters/em',
-          Figure: 'coradoc/html/input/converters/figure',
-          H: 'coradoc/html/input/converters/h',
-          Head: 'coradoc/html/input/converters/head',
-          Hr: 'coradoc/html/input/converters/hr',
-          Img: 'coradoc/html/input/converters/img',
-          Li: 'coradoc/html/input/converters/li',
-          Mark: 'coradoc/html/input/converters/mark',
-          Math: 'coradoc/html/input/converters/math',
-          MediaBase: 'coradoc/html/input/converters/media_base',
-          Ol: 'coradoc/html/input/converters/ol',
-          P: 'coradoc/html/input/converters/p',
-          PassThrough: 'coradoc/html/input/converters/pass_through',
-          PositionalFormatting: 'coradoc/html/input/converters/positional_formatting',
-          Pre: 'coradoc/html/input/converters/pre',
-          Q: 'coradoc/html/input/converters/q',
-          Strong: 'coradoc/html/input/converters/strong',
-          Sup: 'coradoc/html/input/converters/sup',
-          Sub: 'coradoc/html/input/converters/sub',
-          Table: 'coradoc/html/input/converters/table',
-          Td: 'coradoc/html/input/converters/td',
-          Text: 'coradoc/html/input/converters/text',
-          Tr: 'coradoc/html/input/converters/tr',
-          Video: 'coradoc/html/input/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.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.config.unknown_tags.inspect} for Coradoc::Input::Html.config.unknown_tags"
-          end
-        end
-      end
-    end
-  end
-end