coradoc 1.1.7 → 2.0.2

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (source) to HTML <pre><code>
+      class Source < Base
+        # Convert CoreModel::Block (source) to HTML <pre><code>
+        def self.to_html(source, _options = {})
+          return '' unless source
+
+          # Build title if present
+          title_html = build_title(source)
+
+          # Build code attributes with language
+          code_attrs = build_code_attributes(source)
+
+          # Build pre attributes
+          pre_attrs = build_pre_attributes(source)
+
+          # Process source content
+          content = process_content(source.content)
+
+          # Combine into source block
+          source_html = ''
+          source_html += "#{title_html}\n" if title_html
+          source_html += %(<pre#{pre_attrs}><code#{code_attrs}>#{content}</code></pre>)
+
+          if title_html
+            %(<div class="source-block">\n#{source_html}\n</div>)
+          else
+            source_html
+          end
+        end
+
+        # Convert HTML <pre><code> to CoreModel::Block (source)
+        def self.to_coradoc(element, _options = {})
+          # Handle <div class="source-block"><pre><code>, <pre><code>, or <code>
+          code_elem = if element.name == 'div' && element['class']&.include?('source-block')
+                        element.at_css('code')
+                      elsif element.name == 'pre'
+                        element.at_css('code')
+                      elsif element.name == 'code'
+                        element
+                      else
+                        return nil
+                      end
+
+          return nil unless code_elem
+
+          # Extract title if in source-block wrapper
+          title = if element.name == 'div'
+                    title_elem = element.at_css('.source-title')
+                    title_elem&.text&.strip
+                  end
+
+          # Extract language from class
+          language = extract_language(code_elem)
+
+          # Extract content
+          content = code_elem.text
+
+          # Extract ID if present
+          id = code_elem['id'] || element['id']
+
+          Coradoc::CoreModel::Block.new(
+            delimiter_type: '----',
+            content: content,
+            title: title,
+            id: id,
+            language: language
+          )
+        end
+
+        def self.build_code_attributes(source)
+          attrs = []
+
+          # Add language class if present
+          lang = source.language
+
+          attrs << %( class="language-#{escape_attribute(lang)}") if lang && !lang.empty?
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(source.id)}") if source.id
+
+          attrs.join
+        end
+
+        def self.build_pre_attributes(_source)
+          %( class="source")
+        end
+
+        def self.build_title(source)
+          return nil unless source.title
+
+          title_text = source.title.to_s
+          return nil if title_text.empty?
+
+          %(<div class="source-title">#{escape_html(title_text)}</div>)
+        end
+
+        def self.process_content(content)
+          return '' if content.nil?
+
+          # For source code, preserve the content exactly
+          if content.is_a?(String)
+            escape_html(content)
+          elsif content.is_a?(Array)
+            # Join array items with newlines
+            content.map { |line| escape_html(line.to_s) }.join("\n")
+          else
+            escape_html(content.to_s)
+          end
+        end
+
+        def self.extract_language(element)
+          return nil unless element['class']
+
+          # Extract language from class like "language-ruby", "lang-python", etc.
+          classes = element['class'].split
+          lang_class = classes.find { |c| c.start_with?('language-', 'lang-') }
+          return nil unless lang_class
+
+          lang_class.sub(/^(language-|lang-)/, '')
+        end
+      end
+
+      # Converter for SourceCode blocks
+      #
+      # SourceCode models use the `lines` attribute, while Source models use `content`.
+      # This converter inherits from Source and handles the lines attribute properly.
+      class SourceCode < Source
+        # The parent Source class already handles both content and lines attributes
+        # after our recent update, so we just need to inherit.
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for SourceCode blocks
+      #
+      # SourceCode models use the `lines` attribute, while Source models use `content`.
+      class SourceCode < Source
+        # The parent Source class already handles both content and lines attributes
+        # after our recent update, so we just need to inherit.
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for generic Span inline element
+      class Span < Base
+        class << self
+          # Convert HTML <span> to CoreModel::InlineElement
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::InlineElement] Span inline element
+          def to_coradoc(node, state = {})
+            text = node.inner_text
+            attrs = extract_node_attributes(node)
+
+            # Collect all children for potential mixed content
+            children = node.children.flat_map do |child|
+              convert_node_to_core(child, state)
+            end.compact
+
+            span = Coradoc::CoreModel::InlineElement.new(
+              format_type: 'span',
+              content: text
+            )
+
+            # Set class from attributes as metadata
+            span.set_metadata(:class, attrs[:class]) if attrs[:class]
+
+            # If there are children (mixed content), use them
+            span.children = children if children.any?
+
+            span
+          end
+
+          # Convert CoreModel::InlineElement (span) to HTML <span>
+          # @param model [Coradoc::CoreModel::InlineElement] Span model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, state = {})
+            # Prefer children for mixed content, fall back to content
+            content = if model.respond_to?(:children) && model.children&.any?
+                        model.children.map { |c| convert_content_to_html(c, state) }.join
+                      else
+                        escape_html(model.content || '')
+                      end
+
+            # Build attributes from metadata
+            attrs = {}
+            if model.respond_to?(:metadata) && model.metadata && model.metadata[:class]
+              attrs[:class] =
+                model.metadata[:class]
+            end
+
+            build_element('span', content, attrs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Strikethrough inline element
+      class Strikethrough < Base
+        class << self
+          # Convert HTML <del>, <s>, or <strike> to CoreModel::InlineElement
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::InlineElement] Strikethrough inline element
+          def to_coradoc(node, state = {})
+            content = treat_children(node, state)
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: 'strikethrough',
+              content: content
+            )
+          end
+
+          # Convert CoreModel::InlineElement (strikethrough) to HTML <del>
+          # @param model [Coradoc::CoreModel::InlineElement] Strikethrough model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, state = {})
+            content = convert_content_to_html(model.content, state)
+            attributes = extract_model_attributes(model)
+            build_element('del', content, attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Subscript inline element
+      class Subscript < Base
+        class << self
+          # Convert HTML <sub> to CoreModel::InlineElement
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::InlineElement] Subscript inline element
+          def to_coradoc(node, state = {})
+            content = treat_children(node, state)
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: 'subscript',
+              content: content
+            )
+          end
+
+          # Convert CoreModel::InlineElement (subscript) to HTML <sub>
+          # @param model [Coradoc::CoreModel::InlineElement] Subscript model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, state = {})
+            content = convert_content_to_html(model.content, state)
+            attributes = extract_model_attributes(model)
+            build_element('sub', content, attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Superscript inline element
+      class Superscript < Base
+        class << self
+          # Convert HTML <sup> to CoreModel::InlineElement
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::InlineElement] Superscript inline element
+          def to_coradoc(node, state = {})
+            content = treat_children(node, state)
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: 'superscript',
+              content: content
+            )
+          end
+
+          # Convert CoreModel::InlineElement (superscript) to HTML <sup>
+          # @param model [Coradoc::CoreModel::InlineElement] Superscript model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, state = {})
+            content = convert_content_to_html(model.content, state)
+            attributes = extract_model_attributes(model)
+            build_element('sup', content, attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Table < Base
+        # Convert CoreModel::Table to HTML <table>
+        def self.to_html(table, _options = {})
+          attrs = build_attributes(table)
+          caption = build_caption(table)
+
+          rows_html = table.rows.map do |row|
+            TableRow.to_html(row)
+          end.join("\n")
+
+          table_content = rows_html
+          table_content = "#{caption}\n#{table_content}" if caption
+
+          "<table#{attrs}>\n#{table_content}\n</table>"
+        end
+
+        # Convert HTML <table> to CoreModel::Table
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'table'
+
+          rows = element.css('tr').map do |tr|
+            TableRow.to_coradoc(tr)
+          end.compact
+
+          # Extract caption if present
+          caption_elem = element.at_css('caption')
+          title = caption_elem&.text&.strip
+
+          # Extract table attributes
+          attrs = extract_table_attributes(element)
+
+          table = Coradoc::CoreModel::Table.new(
+            rows: rows,
+            title: title
+          )
+          table.id = attrs[:id] if attrs[:id]
+          table.frame = attrs[:frame] if attrs[:frame]
+
+          table
+        end
+
+        def self.build_attributes(table)
+          attrs = []
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(table.id)}") if table.respond_to?(:id) && table.id
+
+          # CoreModel::Table with frame attribute
+          attrs << %( class="frame-#{escape_attribute(table.frame)}") if table.respond_to?(:frame) && table.frame
+
+          attrs.join
+        end
+
+        def self.build_caption(table)
+          return nil unless table.respond_to?(:title) && table.title
+
+          caption_text = table.title.to_s
+          return nil if caption_text.empty?
+
+          "<caption>#{escape_html(caption_text)}</caption>"
+        end
+
+        def self.extract_table_attributes(element)
+          attrs = {}
+
+          # Extract id attribute
+          attrs[:id] = element['id'] if element['id']
+
+          # Extract frame attribute from class
+          if element['class']&.include?('frame-')
+            frame = element['class'][/frame-(\w+)/, 1]
+            attrs[:frame] = frame if frame
+          end
+
+          attrs
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class TableCell < Base
+        # Convert CoreModel::TableCell to HTML <td> or <th>
+        #
+        # @param cell [Coradoc::CoreModel::TableCell] Table cell model
+        # @param _options [Hash] Conversion options
+        # @return [String] HTML string
+        def self.to_html(cell, _options = {})
+          return '' unless cell
+
+          # Check if this is a header cell
+          is_header = cell.respond_to?(:header) && cell.header == true
+          tag = is_header ? 'th' : 'td'
+
+          # Build cell attributes
+          attrs = build_attributes(cell)
+
+          # Process cell content
+          content = process_content(cell)
+
+          # Wrap content in style tags if needed
+          content = wrap_with_style(content, cell)
+
+          "<#{tag}#{attrs}>#{content}</#{tag}>"
+        end
+
+        # Convert HTML <td> or <th> to CoreModel::TableCell
+        def self.to_coradoc(element, _options = {})
+          return nil unless %w[td th].include?(element.name)
+
+          # Determine if this is a header cell
+          is_header = element.name == 'th'
+
+          # Extract content - could be text or nested elements
+          content = extract_content(element)
+
+          # Extract cell attributes
+          attrs = extract_cell_attributes(element)
+
+          Coradoc::CoreModel::TableCell.new(
+            content: content,
+            header: is_header,
+            **attrs.compact
+          )
+        end
+
+        # Build HTML attributes from CoreModel::TableCell
+        def self.build_attributes(cell)
+          attrs = []
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(cell.id)}") if cell.respond_to?(:id) && cell.id
+
+          # Colspan and rowspan
+          attrs << %( colspan="#{cell.colspan}") if cell.respond_to?(:colspan) && cell.colspan
+          attrs << %( rowspan="#{cell.rowspan}") if cell.respond_to?(:rowspan) && cell.rowspan
+
+          # Build style attribute for alignment, colors, etc.
+          style_parts = []
+
+          # Horizontal alignment
+          style_parts << "text-align: #{escape_attribute(cell.alignment)}" if cell.respond_to?(:alignment) && cell.alignment
+
+          # Vertical alignment
+          style_parts << "vertical-align: #{escape_attribute(cell.vertical_alignment)}" if cell.respond_to?(:vertical_alignment) && cell.vertical_alignment
+
+          # Background color
+          style_parts << "background-color: #{escape_attribute(cell.bgcolor)}" if cell.respond_to?(:bgcolor) && cell.bgcolor
+
+          # Text color
+          style_parts << "color: #{escape_attribute(cell.color)}" if cell.respond_to?(:color) && cell.color
+
+          # Width
+          style_parts << "width: #{escape_attribute(cell.width)}" if cell.respond_to?(:width) && cell.width
+
+          # Height
+          style_parts << "height: #{escape_attribute(cell.height)}" if cell.respond_to?(:height) && cell.height
+
+          # Add style attribute if we have any styles
+          attrs << %( style="#{style_parts.join('; ')}") if style_parts.any?
+
+          attrs.join
+        end
+
+        # Wrap content with style tags based on cell style
+        def self.wrap_with_style(content, cell)
+          return content unless cell.respond_to?(:style) && cell.style
+
+          case cell.style.to_s.downcase
+          when 'strong', 's'
+            "<strong>#{content}</strong>"
+          when 'emphasis', 'e'
+            "<em>#{content}</em>"
+          when 'monospace', 'm'
+            "<code>#{content}</code>"
+          when 'literal', 'l'
+            # Literal content - preserve whitespace
+            "<pre>#{content}</pre>"
+          when 'verse', 'v'
+            # Verse content - preserve formatting
+            "<div class=\"verse\">#{content}</div>"
+          else
+            content
+          end
+        end
+
+        def self.process_content(cell)
+          return '' if cell.nil?
+
+          # Use renderable_content if available (prefers children over content)
+          content = if cell.respond_to?(:renderable_content)
+                      cell.renderable_content
+                    elsif cell.respond_to?(:children) && cell.children.any?
+                      cell.children
+                    elsif cell.respond_to?(:content)
+                      cell.content
+                    else
+                      cell
+                    end
+
+          if content.is_a?(Array)
+            content.map { |item| convert_item(item) }.join
+          else
+            convert_item(content)
+          end
+        end
+
+        def self.convert_item(item)
+          case item
+          when String
+            escape_html(item)
+          else
+            # Use convert_content_to_html for CoreModel types
+            convert_content_to_html(item, {})
+          end
+        end
+
+        def self.extract_content(element)
+          # Extract content from the cell
+          children = element.children
+
+          if children.size == 1 && children.first.text?
+            # Simple text content
+            children.first.text
+          else
+            # Complex content with nested elements
+            children.map do |child|
+              if child.text?
+                child.text
+              else
+                # Convert HTML element to CoreModel
+                convert_node_to_core(child, {})
+              end
+            end.compact
+          end
+        end
+
+        def self.extract_cell_attributes(element)
+          attrs = {}
+
+          # Extract colspan
+          attrs[:colspan] = element['colspan'].to_i if element['colspan']
+
+          # Extract rowspan
+          attrs[:rowspan] = element['rowspan'].to_i if element['rowspan']
+
+          # Extract styles from style attribute
+          if element['style']
+            style = element['style']
+
+            # Horizontal alignment
+            if style.include?('text-align')
+              align = style[/text-align:\s*(\w+)/, 1]
+              attrs[:alignment] = align if align
+            end
+
+            # Vertical alignment
+            if style.include?('vertical-align')
+              valign = style[/vertical-align:\s*(\w+)/, 1]
+              attrs[:vertical_alignment] = valign if valign
+            end
+
+            # Background color
+            if style.include?('background-color')
+              bgcolor = style[/background-color:\s*([^;]+)/, 1]
+              attrs[:bgcolor] = bgcolor.strip if bgcolor
+            end
+
+            # Text color
+            if style.include?('color:')
+              color = style[/color:\s*([^;]+)/, 1]
+              attrs[:color] = color.strip if color
+            end
+
+            # Width
+            if style.include?('width:')
+              width = style[/width:\s*([^;]+)/, 1]
+              attrs[:width] = width.strip if width
+            end
+
+            # Height
+            if style.include?('height:')
+              height = style[/height:\s*([^;]+)/, 1]
+              attrs[:height] = height.strip if height
+            end
+          end
+
+          attrs
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class TableRow < Base
+        # Convert CoreModel::TableRow to HTML <tr>
+        def self.to_html(row, _options = {})
+          return '' unless row
+
+          # CoreModel::TableRow uses cells
+          cells = row.respond_to?(:cells) ? row.cells : []
+          columns_html = cells.map do |cell|
+            TableCell.to_html(cell)
+          end.join("\n")
+
+          attrs = build_attributes(row)
+
+          "<tr#{attrs}>\n#{columns_html}\n</tr>"
+        end
+
+        # Convert HTML <tr> to CoreModel::TableRow
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'tr'
+
+          # Get all cells (both td and th)
+          cells = element.css('td, th').map do |cell_elem|
+            TableCell.to_coradoc(cell_elem)
+          end.compact
+
+          Coradoc::CoreModel::TableRow.new(cells: cells)
+        end
+
+        def self.build_attributes(row)
+          attrs = []
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(row.id)}") if row.respond_to?(:id) && row.id
+
+          attrs.join
+        end
+      end
+    end
+  end
+end