coradoc-html 1.1.18 → 1.1.20

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

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Markup < Base
-          def to_coradoc(node, state = {})
-            u_before = unconstrained_before?(node)
-            u_after = unconstrained_after?(node)
-
-            leading_ws, trailing_ws =
-              extract_leading_trailing_whitespace(node)
-
-            # Wrap whitespace in InlineElement so it can be processed
-            leading_whitespace = if leading_ws
-                                   Coradoc::CoreModel::TextElement.new(
-                                     content: leading_ws
-                                   )
-                                 end
-            trailing_whitespace = if trailing_ws
-                                    Coradoc::CoreModel::TextElement.new(
-                                      content: trailing_ws
-                                    )
-                                  end
-
-            content = treat_children_coradoc(node, state)
-
-            if node_has_ancestor?(node, markup_ancestor_tag_names)
-              content
-            elsif node.children.empty?
-              # Return InlineElement wrapper for whitespace
-              if leading_ws
-                Coradoc::CoreModel::TextElement.new(
-                  content: leading_ws
-                )
-              end
-            else
-              u = (u_before && leading_whitespace.nil?) ||
-                  (u_after && trailing_whitespace.nil?)
-
-              # Separate text strings from InlineElements in content array
-              text_content, nested = extract_text_and_elements(content)
-
-              # Create CoreModel::InlineElement with the appropriate format type
-              inline_element = Coradoc::CoreModel::InlineElement.format_type_class(coradoc_format_type).new(
-                content: text_content,
-                nested_elements: nested.empty? ? nil : nested,
-                metadata: { unconstrained: u }
-              )
-              result = [leading_whitespace, inline_element, trailing_whitespace].compact
-              result.length == 1 ? result.first : result
-            end
-          end
-
-          # Extract text content and InlineElements from mixed content array
-          def extract_text_and_elements(content)
-            return [content, []] unless content.is_a?(Array)
-
-            text_parts = []
-            elements = []
-
-            content.each do |item|
-              case item
-              when String
-                text_parts << item
-              when Coradoc::CoreModel::InlineElement
-                elements << item
-              when Coradoc::CoreModel::Base
-                # For other block types, convert to text
-                text_parts << extract_text_from_model(item)
-              else
-                text_parts << item.to_s
-              end
-            end
-
-            [text_parts.join, elements]
-          end
-
-          # Extract text from a CoreModel object
-          def extract_text_from_model(model)
-            return '' if model.nil?
-
-            if model.is_a?(Coradoc::CoreModel::Base) && model.content.is_a?(String)
-              model.content
-            elsif model.is_a?(Coradoc::CoreModel::StructuralElement) && model.children.is_a?(Array)
-              model.children.map { |c| extract_text_from_model(c) }.join
-            elsif model.is_a?(Coradoc::CoreModel::Base) && model.title.is_a?(String)
-              model.title
-            else
-              model.to_s
-            end
-          end
-
-          # Subclasses should override this to return the format type
-          def coradoc_format_type
-            'text'
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Math < Base
-          INSTANCE = new
-
-          def to_coradoc(node, _state = {})
-            stem = node.to_s.tr("\n", ' ')
-            if Coradoc::Html::Input.config.mathml2asciimath
-              require 'plurimath'
-              stem = Plurimath::Math.parse(stem, :mathml).to_asciimath
-            end
-
-            unless stem.nil?
-              stem = stem.gsub('[', '\\[')
-              stem = stem.gsub(']', '\\]')
-              loop do
-                new_stem = stem.gsub(/\(\(([^)]{1,100})\)\)/, '(\\1)')
-                break if new_stem == stem
-
-                stem = new_stem
-              end
-            end
-
-            Coradoc::CoreModel::StemElement.new(
-              content: stem,
-              stem_type: 'mathml'
-            )
-          end
-        end
-
-        register :math, Math::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class MediaBase < Base
-          def to_coradoc(node, _state = {})
-            src = node['src']
-            id = node['id']
-            title = extract_title(node)
-
-            Coradoc::CoreModel::Block.new(
-              block_semantic_type: semantic_type,
-              content: src,
-              title: title,
-              id: id,
-              element_attributes: build_attributes(node)
-            )
-          end
-
-          def extract_title(node)
-            track = node.at('./track') || node.at('.//source')
-            return '' if track.nil?
-
-            track['label'] || track['srclang'] || ''
-          end
-
-          private
-
-          def semantic_type
-            raise NotImplementedError
-          end
-
-          def base_attributes(node)
-            {
-              autoplay: node['autoplay'],
-              loop: node['loop'],
-              controls: node['controls']
-            }.compact
-          end
-
-          def build_attributes(node)
-            base_attributes(node)
-          end
-        end
-      end
-    end
-  end
-end

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