coradoc-html 1.1.7

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (open) to HTML
+      class Open < Base
+        def self.to_html(block, _options = {})
+          return '' unless block
+
+          # Build content
+          content = process_content(block.content)
+
+          # Build attributes
+          attrs = build_attributes(block)
+
+          # Wrap in div with openblock class
+          "<div#{attrs}>\n#{content}\n</div>"
+        end
+
+        # Convert HTML div to CoreModel::Block (open)
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'div'
+
+          # Extract content
+          content = element.children.map do |node|
+            if node.text? && !node.text.strip.empty?
+              node.text.strip
+            elsif node.element?
+              case node.name
+              when 'p'
+                Paragraph.to_coradoc(node)
+              else
+                node.text.strip
+              end
+            end
+          end.compact
+
+          # Extract ID if present
+          id = element['id']
+
+          Coradoc::CoreModel::OpenBlock.new(
+            content: content,
+            id: id
+          )
+        end
+
+        def self.build_attributes(block)
+          attrs = []
+          attrs << %( class="openblock")
+
+          attrs << %( id="#{escape_attribute(block.id)}") if block.id
+
+          attrs.join
+        end
+
+        def self.process_content(content)
+          return '' if content.nil?
+
+          if content.is_a?(Array)
+            content.map { |item| convert_item(item) }.join("\n")
+          else
+            convert_item(content)
+          end
+        end
+
+        def self.convert_item(item)
+          case item
+          when String
+            "<p>#{escape_html(item)}</p>"
+          else
+            convert_content_to_html(item)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Ordered (numbered) lists
+      class Ordered < Base
+        class << self
+          # Convert HTML <ol> to CoreModel::ListBlock
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::ListBlock] Ordered list model
+          def to_coradoc(node, state = {})
+            items = node.css('> li').map do |li_node|
+              Coradoc::Html::Converters::ListItem.to_coradoc(li_node, state)
+            end
+
+            attrs = extract_node_attributes(node)
+
+            list = Coradoc::CoreModel::ListBlock.new(
+              marker_type: 'ordered',
+              items: items
+            )
+            list.id = attrs[:id] if attrs[:id]
+
+            # Extract start value if present
+            list.start = attrs[:start].to_i if attrs[:start]
+
+            list
+          end
+
+          # Convert CoreModel::ListBlock (ordered) to HTML <ol>
+          # @param model [Coradoc::CoreModel::ListBlock] Ordered list model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, state = {})
+            items_html = model.items.map do |item|
+              Coradoc::Html::Converters::ListItem.to_html(item, state)
+            end.join("\n")
+
+            attrs = {}
+            attrs[:id] = model.id if model.id
+
+            # Add start attribute if not starting from 1
+            attrs[:start] = model.start if model.start && model.start != 1
+
+            build_element('ol', "\n#{items_html}\n", attrs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Paragraph block element
+      class Paragraph < Base
+        class << self
+          # Convert HTML <p> to CoreModel Block
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::Block] Block model with element_type: paragraph
+          def to_coradoc(node, state = {})
+            content = treat_children(node, state)
+            attrs = extract_node_attributes(node)
+
+            # Create paragraph block with content
+            paragraph = Coradoc::CoreModel::Block.new(
+              element_type: 'paragraph',
+              children: [content]
+            )
+
+            # Set ID if present
+            paragraph.id = attrs[:id] if attrs[:id]
+
+            paragraph
+          end
+
+          # Convert CoreModel::Block (element_type: paragraph) to HTML <p>
+          # @param model [Coradoc::CoreModel::Block] Paragraph block model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, state = {})
+            # Use renderable_content to handle both content and children
+            content_to_render = model.renderable_content
+            content = convert_content_to_html(content_to_render, state)
+            # Strip trailing whitespace from content to avoid issues with line breaks
+            content = content.rstrip
+            attributes = extract_model_attributes(model)
+            build_element('p', content, attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (quote) to HTML <blockquote>
+      class Quote < Base
+        # Convert CoreModel::Block (quote) to HTML <blockquote>
+        def self.to_html(quote, _options = {})
+          return '' unless quote
+
+          # Build blockquote attributes
+          attrs = build_attributes(quote)
+
+          # Process quote content
+          content = process_content(quote.content)
+
+          # Build attribution if present
+          attribution = build_attribution(quote)
+
+          # Combine content and attribution
+          quote_html = content
+          quote_html += "\n#{attribution}" if attribution
+
+          "<blockquote#{attrs}>\n#{quote_html}\n</blockquote>"
+        end
+
+        # Convert HTML <blockquote> to CoreModel::Block (quote)
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'blockquote'
+
+          # Extract content - all children except cite/footer
+          content_nodes = element.children.reject do |node|
+            %w[cite footer].include?(node.name)
+          end
+
+          content = extract_content(content_nodes)
+
+          # Extract attribution from <cite> or <footer>
+          cite_elem = element.at_css('cite, footer')
+          attribution = cite_elem&.text&.strip
+
+          # Extract ID if present
+          id = element['id']
+
+          Coradoc::CoreModel::QuoteBlock.new(
+            content: content,
+            id: id,
+            attribution: attribution
+          )
+        end
+
+        def self.build_attributes(quote)
+          attrs = []
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(quote.id)}") if quote.id
+
+          attrs.join
+        end
+
+        def self.process_content(content)
+          return '' if content.nil?
+
+          if content.is_a?(Array)
+            content.map { |item| convert_item(item) }.join("\n")
+          elsif content.is_a?(String)
+            "<p>#{escape_html(content)}</p>"
+          else
+            convert_item(content)
+          end
+        end
+
+        def self.convert_item(item)
+          case item
+          when String
+            "<p>#{escape_html(item)}</p>"
+          else
+            # Use centralized content conversion
+            convert_content_to_html(item)
+          end
+        end
+
+        def self.build_attribution(quote)
+          # Check metadata for attribution
+          attribution_text = quote.metadata&.dig(:attribution)
+          return nil unless attribution_text
+
+          attribution_text = attribution_text.to_s.strip
+          return nil if attribution_text.empty?
+
+          %(<footer>#{escape_html(attribution_text)}</footer>)
+        end
+
+        def self.extract_content(nodes)
+          # Extract and convert content nodes
+          nodes.map do |node|
+            if node.text? && !node.text.strip.empty?
+              node.text.strip
+            elsif node.element?
+              case node.name
+              when 'p'
+                Paragraph.to_coradoc(node)
+              else
+                node.text.strip
+              end
+            end
+          end.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::AnnotationBlock (reviewer comment) to HTML
+      class ReviewerComment < Base
+        # Convert CoreModel::AnnotationBlock (reviewer comment) to HTML
+        def self.to_html(comment, _options = {})
+          return '' unless comment
+
+          # Build attributes
+          attrs = build_attributes(comment)
+
+          # Process content
+          content = process_content(comment.content)
+
+          # Parse reviewer info from metadata
+          reviewer_info = extract_reviewer_info(comment.metadata)
+
+          %(<div#{attrs}>
+<span class="reviewer-note-label">Reviewer Note</span>
+#{reviewer_info}
+<div class="reviewer-note-content">
+#{content}
+</div>
+</div>)
+        end
+
+        def self.build_attributes(comment)
+          attrs = [%( class="reviewer-note")]
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(comment.id)}") if comment.id
+
+          attrs.join
+        end
+
+        def self.process_content(content)
+          return '' if content.nil?
+
+          if content.is_a?(String)
+            escape_html(content)
+          elsif content.is_a?(Array)
+            content.map { |item| convert_item(item) }.join("\n")
+          else
+            convert_item(content)
+          end
+        end
+
+        def self.convert_item(item)
+          case item
+          when String
+            escape_html(item)
+          else
+            convert_content_to_html(item)
+          end
+        end
+
+        def self.extract_reviewer_info(metadata)
+          return '' if metadata.nil?
+
+          # Extract reviewer info from metadata
+          reviewer = metadata[:reviewer]
+          return '' unless reviewer
+
+          %(<div class="reviewer-note-metadata">
+<span class="metadata-item">reviewer=#{escape_html(reviewer)}</span>
+</div>)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::AnnotationBlock (reviewer note) to HTML <aside>
+      class ReviewerNote < Base
+        # Convert CoreModel::AnnotationBlock (reviewer note) to HTML <aside>
+        def self.to_html(reviewer_note, options = {})
+          return '' unless reviewer_note
+
+          # Build aside attributes with reviewer metadata
+          attrs = build_attributes(reviewer_note)
+
+          # Build header with label and visible metadata
+          header = build_header(reviewer_note)
+
+          # Process reviewer note content
+          content = process_content(reviewer_note.content, options)
+
+          %(<aside#{attrs}>\n#{header}#{content}\n</div>\n</aside>)
+        end
+
+        # Convert HTML <aside> with reviewer data to CoreModel::AnnotationBlock
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'aside'
+          return nil unless element['data-reviewer'] # Must have reviewer attribute
+
+          # Extract reviewer metadata
+          reviewer = element['data-reviewer']
+          date = element['data-date']
+          from = element['data-from']
+          to = element['data-to']
+
+          # Extract content
+          content = extract_content(element.children)
+
+          Coradoc::CoreModel::AnnotationBlock.new(
+            annotation_type: 'reviewer_note',
+            content: content,
+            metadata: {
+              reviewer: reviewer,
+              date: date,
+              from: from,
+              to: to
+            }
+          )
+        end
+
+        def self.build_header(reviewer_note)
+          # Build header with label and visible metadata
+          header_parts = []
+          header_parts << %(<div class="reviewer-note-header">)
+          header_parts << %(  <span class="reviewer-note-label">Reviewer's note</span>)
+
+          # Build metadata display if any metadata exists
+          metadata_items = []
+          metadata = reviewer_note.metadata || {}
+          metadata_items << %(reviewer=#{escape_html(metadata[:reviewer])}) if metadata[:reviewer]
+          metadata_items << %(date=#{escape_html(metadata[:date])}) if metadata[:date]
+          metadata_items << %(from=#{escape_html(metadata[:from])}) if metadata[:from]
+          metadata_items << %(to=#{escape_html(metadata[:to])}) if metadata[:to]
+
+          unless metadata_items.empty?
+            header_parts << %(  <div class="reviewer-note-metadata">)
+            metadata_items.each do |item|
+              header_parts << %(    <span class="metadata-item">#{item}</span>)
+            end
+            header_parts << %(  </div>)
+          end
+
+          header_parts << %(</div>)
+          header_parts << %(<div class="reviewer-note-content">)
+
+          header_parts.join("\n")
+        end
+
+        def self.build_attributes(reviewer_note)
+          attrs = [%( class="reviewer-note")]
+
+          # Add reviewer metadata as data attributes
+          metadata = reviewer_note.metadata || {}
+
+          attrs << %( data-reviewer="#{escape_html(metadata[:reviewer])}") if metadata[:reviewer]
+
+          attrs << %( data-date="#{escape_html(metadata[:date])}") if metadata[:date]
+
+          attrs << %( data-from="#{escape_html(metadata[:from])}") if metadata[:from]
+
+          attrs << %( data-to="#{escape_html(metadata[:to])}") if metadata[:to]
+
+          attrs.join
+        end
+
+        def self.process_content(content, options = {})
+          return '' if content.nil?
+
+          if content.is_a?(Array)
+            content.map { |item| convert_item(item, options) }.join("\n")
+          elsif content.is_a?(String)
+            "<p>#{escape_html(content)}</p>"
+          else
+            convert_item(content, options)
+          end
+        end
+
+        def self.convert_item(item, _options = {})
+          case item
+          when String
+            "<p>#{escape_html(item)}</p>"
+          else
+            convert_content_to_html(item)
+          end
+        end
+
+        def self.extract_content(nodes)
+          # Extract and convert content nodes
+          nodes.map do |node|
+            if node.text? && !node.text.strip.empty?
+              node.text.strip
+            elsif node.element?
+              case node.name
+              when 'p'
+                Paragraph.to_coradoc(node)
+              else
+                node.text.strip
+              end
+            end
+          end.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Section structural element
+      class Section < Base
+        class << self
+          # Convert HTML <section> to CoreModel::StructuralElement
+          # @param node [Nokogiri::XML::Node] HTML section node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::StructuralElement] Section model
+          def to_coradoc(node, state = {})
+            # Extract section title from heading
+            title_node = node.at('h1, h2, h3, h4, h5, h6')
+            title = title_node&.text&.strip
+            level = title_node ? title_node.name[1].to_i : 1
+
+            # Extract attributes
+            attrs = extract_node_attributes(node)
+
+            # Process children (skip the heading as we already extracted it)
+            child_nodes = node.children.reject { |child| child.name =~ /^h[1-6]$/ }
+            children = child_nodes.flat_map do |child|
+              convert_node_to_core(child, state)
+            end.compact
+
+            # Create CoreModel section
+            section = Coradoc::CoreModel::StructuralElement.new(
+              element_type: 'section',
+              level: level,
+              title: title,
+              children: children
+            )
+
+            # Set ID if present
+            section.id = attrs[:id] if attrs[:id]
+
+            section
+          end
+
+          # Convert CoreModel::StructuralElement to HTML <section>
+          # @param model [Coradoc::CoreModel::StructuralElement] Section model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, state = {})
+            parts = []
+
+            # Add title as heading
+            if model.title
+              # Calculate heading level (level 0 -> h1, level 1 -> h2, etc.)
+              level = model.level || 1
+              heading_level = [[level + 1, 1].max, 6].min # Clamp between h1-h6
+              heading_tag = "h#{heading_level}"
+
+              title_text = escape_html(model.title)
+
+              title_attrs = {}
+              title_attrs[:id] = model.id if model.id
+
+              parts << build_element(heading_tag, title_text, title_attrs)
+            end
+
+            # Add section children (paragraphs, lists, nested sections, etc.)
+            model.children&.each do |child|
+              parts << convert_content_to_html(child, state)
+            end
+
+            # Wrap in section tag
+            content = parts.join("\n")
+            attributes = extract_section_attributes(model)
+            build_element('section', content, attributes)
+          end
+
+          private
+
+          # Extract section-level attributes
+          def extract_section_attributes(model)
+            attrs = {}
+
+            # Don't duplicate ID if already on heading
+            attrs[:id] = model.id if !(model.title && model.id) && model.id
+
+            attrs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (sidebar) to HTML <aside>
+      class Sidebar < Base
+        # Convert CoreModel::Block (sidebar) to HTML <aside>
+        def self.to_html(sidebar, _options = {})
+          return '' unless sidebar
+
+          # Build aside attributes
+          attrs = build_attributes(sidebar)
+
+          # Build title if present
+          title_html = build_title(sidebar)
+
+          # Process sidebar content
+          content = process_content(sidebar.content)
+
+          # Combine title and content
+          sidebar_html = ''
+          sidebar_html += "#{title_html}\n" if title_html
+          sidebar_html += content
+
+          %(<aside#{attrs}>\n#{sidebar_html}\n</aside>)
+        end
+
+        # Convert HTML <aside> to CoreModel::Block (sidebar)
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'aside'
+
+          # Extract title if present
+          title_elem = element.at_css('.sidebar-title, h1, h2, h3, h4, h5, h6')
+          title = title_elem&.text&.strip
+
+          # Extract content - all children except title
+          content_nodes = if title_elem
+                            element.children.reject { |node| node == title_elem }
+                          else
+                            element.children
+                          end
+
+          content = extract_content(content_nodes)
+
+          # Extract ID if present
+          id = element['id']
+
+          Coradoc::CoreModel::SidebarBlock.new(
+            content: content,
+            title: title,
+            id: id
+          )
+        end
+
+        def self.build_attributes(sidebar)
+          attrs = [%( class="sidebar")]
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(sidebar.id)}") if sidebar.id
+
+          attrs.join
+        end
+
+        def self.build_title(sidebar)
+          return nil unless sidebar.title
+
+          title_text = sidebar.title.to_s
+          return nil if title_text.empty?
+
+          %(<div class="sidebar-title">#{escape_html(title_text)}</div>)
+        end
+
+        def self.process_content(content)
+          return '' if content.nil?
+
+          if content.is_a?(Array)
+            content.map { |item| convert_item(item) }.join("\n")
+          elsif content.is_a?(String)
+            "<p>#{escape_html(content)}</p>"
+          else
+            convert_item(content)
+          end
+        end
+
+        def self.convert_item(item)
+          case item
+          when String
+            "<p>#{escape_html(item)}</p>"
+          else
+            convert_content_to_html(item)
+          end
+        end
+
+        def self.extract_content(nodes)
+          # Extract and convert content nodes
+          nodes.map do |node|
+            if node.text? && !node.text.strip.empty?
+              node.text.strip
+            elsif node.element?
+              case node.name
+              when 'p'
+                Paragraph.to_coradoc(node)
+              else
+                node.text.strip
+              end
+            end
+          end.compact
+        end
+      end
+    end
+  end
+end