coradoc-html 1.1.18 → 1.1.19

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Figure < Base
+        INSTANCE = new
+
+        def to_coradoc(node, state = {})
+          id = node['id']
+          title_content = extract_title(node)
+          content = treat_children_coradoc(node, state)
+
+          # Use CoreModel::ExampleBlock for example/figure
+          Coradoc::CoreModel::ExampleBlock.new(
+            title: extract_text_from_content(title_content),
+            children: content,
+            id: id
+          )
+        end
+
+        def extract_title(node)
+          title = node.at('./figcaption')
+          return '' if title.nil?
+
+          treat_children_coradoc(title, {})
+        end
+      end
+
+      register :figure, Figure::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class H < Base
+        INSTANCE = new
+
+        def to_coradoc(node, state = {})
+          id = node['id']
+          internal_anchor = treat_children_anchors(node, state)
+
+          if id.to_s.empty? && internal_anchor.size.positive?
+            first_model = internal_anchor.first
+            id = first_model.target if first_model.is_a?(Coradoc::CoreModel::InlineElement) && first_model.target
+          end
+
+          level_int = node.name[/\d/].to_i
+          content = treat_children_no_anchors(node, state)
+
+          Coradoc::CoreModel::SectionElement.new(
+            title: extract_title_text(content),
+            level: level_int,
+            id: id,
+            children: []
+          )
+        end
+
+        def treat_children_no_anchors(node, state)
+          node.children.reject { |a| a.name == 'a' }
+              .map do |child|
+            treat_coradoc(child, state)
+          end.flatten.compact
+        end
+
+        def treat_children_anchors(node, state)
+          node.children.select { |a| a.name == 'a' }
+              .map do |child|
+            treat_coradoc(child, state)
+          end.flatten.compact
+        end
+
+        private
+
+        def extract_title_text(content)
+          Coradoc::CoreModel::InlineContent.text_of(content).strip
+        end
+      end
+
+      register :h1, H::INSTANCE
+      register :h2, H::INSTANCE
+      register :h3, H::INSTANCE
+      register :h4, H::INSTANCE
+      register :h5, H::INSTANCE
+      register :h6, H::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Head < Base
+        INSTANCE = new
+
+        def to_coradoc(node, _state = {})
+          title = extract_title(node)
+          # Use DocumentElement for document header
+          Coradoc::CoreModel::DocumentElement.new(
+            title: title,
+            level: 0
+          )
+        end
+
+        def extract_title(node)
+          title = node.at('./title')
+          return '(???)' if title.nil?
+
+          title.text
+        end
+      end
+
+      register :head, Head::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Hr < Base
+        INSTANCE = new
+
+        def to_coradoc(_node, _state = {})
+          Coradoc::CoreModel::HorizontalRuleBlock.new
+        end
+      end
+
+      register :hr, Hr::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+require 'tempfile'
+require 'base64'
+require 'marcel'
+
+module Coradoc
+  module Html
+    module Converters
+      class Img < Base
+        INSTANCE = new
+
+        def image_number
+          format(
+            Html.input_config.image_counter_pattern,
+            Html.input_config.image_counter
+          )
+        end
+
+        def image_number_increment
+          Html.input_config.image_counter += 1
+        end
+
+        def datauri2file(src)
+          return unless src
+
+          %r{^data:image/(?:[^;]+);base64,(?<imgdata>.+)$} =~ src
+
+          dest_dir = Pathname.new(Html.input_config.destination).dirname
+          images_dir = dest_dir.join('images')
+          FileUtils.mkdir_p(images_dir)
+
+          ext, image_src_path, tempfile = determine_image_src_path(
+            src,
+            imgdata
+          )
+          image_dest_path = images_dir + "#{image_number}.#{ext}"
+
+          if File.exist?(image_src_path)
+            FileUtils.cp(image_src_path, image_dest_path)
+          else
+            Kernel.warn "Image #{image_src_path} does not exist"
+          end
+
+          image_number_increment
+
+          image_dest_path.relative_path_from(dest_dir)
+        ensure
+          tempfile&.close!
+        end
+
+        def determine_image_src_path(src, imgdata)
+          return copy_temp_file(imgdata) if imgdata
+
+          ext = File.extname(src).strip.downcase[1..]
+          [ext, Pathname.new(Html.input_config.sourcedir).join(src)]
+        end
+
+        def copy_temp_file(imgdata)
+          f = Tempfile.open(['radoc', '.jpg'])
+          f.binmode
+          f.write(Base64.strict_decode64(imgdata))
+          f.rewind
+          ext = Marcel::MimeType.for(f).sub(%r{^[^/]+/}, '')
+          ext = 'svg' if ext == 'svg+xml'
+          [ext, f.path, f]
+        end
+
+        def to_coradoc(node, _state = {})
+          id = node['id']
+          alt   = node['alt']
+          src   = node['src']
+          width = node['width']
+          height = node['height']
+
+          # Convert width/height to integers if they are numeric strings
+          width = width.to_i if width&.match?(/\A\d+\z/)
+          height = height.to_i if height&.match?(/\A\d+\z/)
+
+          title = extract_title(node)
+
+          src = datauri2file(src) if Html.input_config.external_images
+
+          # Use CoreModel::Image
+          return unless src
+
+          Coradoc::CoreModel::Image.new(
+            src: src,
+            alt: alt,
+            caption: title,
+            width: width&.to_s,
+            height: height&.to_s,
+            id: id
+          )
+        end
+      end
+
+      register :img, Img::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Li < Base
+        INSTANCE = new
+
+        def to_coradoc(node, state = {})
+          id = node['id']
+
+          # Check if all children are <p> tags
+          p_children = node.children.select { |child| child.name == 'p' }
+          non_empty_children = node.children.reject { |c| c.text? && c.text.strip.empty? }
+
+          content = if p_children.any? && p_children.size == non_empty_children.size && p_children.size == 1
+                      # Single <p> tag - extract its content directly as inline content
+                      treat_children_coradoc(p_children.first, state)
+                    else
+                      treat_children_coradoc(node, state)
+                    end
+
+          # Use CoreModel::ListItem with children for mixed content
+          # content can be an array of inline elements or a single string
+          Coradoc::CoreModel::ListItem.new(
+            children: content,
+            id: id
+          )
+        end
+      end
+
+      register :li, Li::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Mark < Markup
+        INSTANCE = new
+
+        def coradoc_format_type
+          'highlight'
+        end
+
+        def markup_ancestor_tag_names
+          %w[mark]
+        end
+      end
+
+      register :mark, Mark::INSTANCE
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Coradoc
+  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 via the shared
+        # CoreModel::InlineContent helper. Kept as a thin wrapper so
+        # callers in Markup can pass single elements without wrapping.
+        def extract_text_from_model(model)
+          Coradoc::CoreModel::InlineContent.text_of(model)
+        end
+
+        # Subclasses should override this to return the format type
+        def coradoc_format_type
+          'text'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Math < Base
+        INSTANCE = new
+
+        def to_coradoc(node, _state = {})
+          stem = node.to_s.tr("\n", ' ')
+          if 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

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

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

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

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

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Coradoc
+  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 = strip_fullwidth_per_element(content)
+          content = Coradoc::CoreModel::InlineContent.strip_edges(content)
+          reject_empty_elements(content)
+        end
+
+        # Strip CJK fullwidth spaces from the leading/trailing edge of
+        # every InlineElement's content. Returns a new array; inputs
+        # are not mutated.
+        def strip_fullwidth_per_element(content)
+          content.map do |item|
+            next item unless item.is_a?(Coradoc::CoreModel::InlineElement)
+            next item unless item.content.is_a?(String)
+
+            item.with_content(item.content.gsub(/\A　+|　+\z/, ''))
+          end
+        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

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

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

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

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

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

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