coradoc-html 1.1.7

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Hr < Base
+          def to_coradoc(_node, _state = {})
+            Coradoc::CoreModel::Block.new(
+              element_type: 'thematic_break',
+              block_semantic_type: :horizontal_rule
+            )
+          end
+        end
+
+        register :hr, Hr.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Ignore < Base
+          def to_coradoc(node, state = {})
+            convert(node, state)
+          end
+
+          def convert(_node, _state = {})
+            '' # noop
+          end
+        end
+
+        register :colgroup, Ignore.new
+        register :col,      Ignore.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+require 'tempfile'
+require 'base64'
+require 'marcel'
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Img < Base
+          def image_number
+            format(
+              Coradoc::Html::Input.config.image_counter_pattern,
+              Coradoc::Html::Input.config.image_counter
+            )
+          end
+
+          def image_number_increment
+            Coradoc::Html::Input.config.image_counter += 1
+          end
+
+          def datauri2file(src)
+            return unless src
+
+            %r{^data:image/(?:[^;]+);base64,(?<imgdata>.+)$} =~ src
+
+            dest_dir = Pathname.new(Coradoc::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}"
+
+            # puts "image_dest_path: #{image_dest_path.to_s}"
+            # puts "image_src_path: #{image_src_path.to_s}"
+
+            if File.exist?(image_src_path)
+              FileUtils.cp(image_src_path, image_dest_path)
+            else
+              @annotate_missing = image_src_path
+              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(Coradoc::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)
+
+            if Coradoc::Html::Input.config.external_images
+              # puts "external image conversion #{id}, #{src}"
+              src = datauri2file(src)
+            end
+
+            # 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
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,107 @@
+# 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::InlineElement.new(
+                                     format_type: 'text',
+                                     content: leading_ws
+                                   )
+                                 end
+            trailing_whitespace = if trailing_ws
+                                    Coradoc::CoreModel::InlineElement.new(
+                                      format_type: 'text',
+                                      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::InlineElement.new(
+                  format_type: 'text',
+                  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.new(
+                format_type: coradoc_format_type,
+                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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Unless run with Coradoc::Input::HTML.config.mathml2asciimath,
+# this is cheating: we're injecting MathML into Asciidoctor, but
+# Asciidoctor only understands AsciiMath or LaTeX
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Math < Base
+          # FIXIT
+          def to_coradoc(node, state = {})
+            convert(node, state)
+          end
+
+          def convert(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(']', '\\]')
+              # Handle ((...)) patterns - iterate to avoid polynomial regex
+              loop do
+                new_stem = stem.gsub(/\(\(([^)]{1,100})\)\)/, '(\\1)')
+                break if new_stem == stem
+
+                stem = new_stem
+              end
+            end
+
+            # NOTE: MathML/LaTeX conversion to AsciiDoc stem format
+            # This converts HTML math elements to AsciiDoc's stem:[] macro format
+            ' stem:[' << stem << '] '
+          end
+        end
+
+        register :math, Math.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Ol < Base
+          def to_coradoc(node, state = {})
+            id = node['id']
+            ol_count = state.fetch(:ol_count, 0) + 1
+            items = treat_children_coradoc(
+              node,
+              state.merge(ol_count: ol_count)
+            )
+
+            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.new
+        register :ul, Ol.new
+        register :dir, Ol.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class P < Base
+          def to_coradoc(node, state = {})
+            id = node['id']
+            content = treat_children_coradoc(node, state)
+
+            # Strip full-width spaces from paragraph content
+            content = strip_fullwidth_spaces(content)
+
+            Coradoc::CoreModel::Block.new(
+              block_semantic_type: :paragraph,
+              element_type: 'paragraph',
+              children: content,
+              id: id
+            )
+          end
+
+          private
+
+          def strip_fullwidth_spaces(content)
+            return content unless content.is_a?(Array)
+
+            # Strip full-width spaces from all inline elements
+            content.each do |item|
+              if item.is_a?(Coradoc::CoreModel::InlineElement) && item.content.is_a?(String)
+                item.content = item.content.gsub(/\A　+|　+\z/, '')
+              elsif item.is_a?(String)
+                item.gsub(/\A　+|　+\z/, '')
+              end
+            end
+
+            # Strip leading space from first text element
+            first_text = content.find { |item| item.is_a?(Coradoc::CoreModel::InlineElement) || item.is_a?(String) }
+            if first_text.is_a?(Coradoc::CoreModel::InlineElement) && first_text.content.is_a?(String)
+              first_text.content = first_text.content.lstrip
+            elsif first_text.is_a?(String)
+              first_text.lstrip
+            end
+
+            # Strip trailing space from last text element
+            last_text = content.reverse.find do |item|
+              item.is_a?(Coradoc::CoreModel::InlineElement) || item.is_a?(String)
+            end
+            if last_text.is_a?(Coradoc::CoreModel::InlineElement) && last_text.content.is_a?(String)
+              last_text.content = last_text.content.rstrip
+            elsif last_text.is_a?(String)
+              last_text.rstrip
+            end
+
+            # Remove empty text elements after stripping
+            # But keep InlineElements that have nested_elements (e.g., bold with nested text)
+            content.reject do |item|
+              if item.is_a?(Coradoc::CoreModel::InlineElement)
+                item.content.to_s.empty? && !item_has_nested_content?(item)
+              elsif item.is_a?(String)
+                item.empty?
+              else
+                false
+              end
+            end
+          end
+
+          # Check if InlineElement has meaningful nested content
+          def item_has_nested_content?(item)
+            return false unless item.is_a?(Coradoc::CoreModel::InlineElement)
+            return false if item.nested_elements.nil? || item.nested_elements.empty?
+
+            true
+          end
+        end
+
+        register :p, P.new
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Pre < Base
+          def to_coradoc(node, _state = {})
+            id = node['id']
+            lang = language(node)
+            content = extract_text_content(node)
+
+            if lang
+              Coradoc::CoreModel::SourceBlock.new(
+                element_type: 'source',
+                content: content,
+                id: id,
+                language: lang
+              )
+            else
+              Coradoc::CoreModel::LiteralBlock.new(
+                element_type: 'literal',
+                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.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Q < Base
+          def to_coradoc(node, state = {})
+            content = treat_children_coradoc(node, state)
+            cite = node['cite']
+
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: 'quotation',
+              content: content,
+              metadata: cite ? { cite: cite } : {}
+            )
+          end
+        end
+
+        register :q, Q.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Strong < Markup
+          def coradoc_format_type
+            'bold'
+          end
+
+          def markup_ancestor_tag_names
+            %w[strong b]
+          end
+        end
+
+        register :strong, Strong.new
+        register :b,      Strong.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Sub < 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 "subscript"
+            e = Coradoc::CoreModel::InlineElement.new(
+              format_type: 'subscript',
+              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 :sub, Sub.new
+      end
+    end
+  end
+end