coradoc-html 1.1.7

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (bibliography) to HTML bibliography section
+      class Bibliography < Base
+        # Convert CoreModel::Block (bibliography) to HTML bibliography section
+        def self.to_html(bibliography, _options = {})
+          return '' unless bibliography
+
+          # Build section attributes
+          attrs = build_attributes(bibliography)
+
+          # Build title
+          title_html = build_title(bibliography)
+
+          # Process bibliography entries (children)
+          entries = bibliography.children || []
+          entries_html = entries.map do |entry|
+            BibliographyEntry.to_html(entry)
+          end.join("\n")
+
+          # Combine into bibliography section
+          bib_html = ''
+          bib_html += "#{title_html}\n" if title_html
+          bib_html += %(<div class="bibliography-entries">\n#{entries_html}\n</div>) unless entries_html.empty?
+
+          %(<section#{attrs}>\n#{bib_html}\n</section>)
+        end
+
+        # Convert HTML bibliography section to CoreModel::Block (bibliography)
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'section'
+          return nil unless element['class']&.include?('bibliography')
+
+          # Extract title
+          title_elem = element.at_css('h1, h2, h3, h4, h5, h6, .bibliography-title')
+          title = title_elem&.text&.strip
+
+          # Extract entries
+          entries_container = element.at_css('.bibliography-entries')
+          entries = if entries_container
+                      entries_container.css('.bibliography-entry').map do |entry_elem|
+                        BibliographyEntry.to_coradoc(entry_elem)
+                      end.compact
+                    else
+                      []
+                    end
+
+          # Extract ID if present
+          id = element['id']
+
+          Coradoc::CoreModel::Block.new(
+            element_type: 'bibliography',
+            title: title,
+            id: id,
+            children: entries
+          )
+        end
+
+        def self.build_attributes(bibliography)
+          attrs = [%( class="bibliography")]
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(bibliography.id)}") if bibliography.id
+
+          attrs.join
+        end
+
+        def self.build_title(bibliography)
+          return nil unless bibliography.title
+
+          title_text = bibliography.title.to_s
+          return nil if title_text.empty?
+
+          %(<h2 class="bibliography-title">#{escape_html(title_text)}</h2>)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (bibliography entry) to HTML bibliography entry
+      class BibliographyEntry < Base
+        # Convert CoreModel::Block (bibliography entry) to HTML bibliography entry
+        def self.to_html(entry, _options = {})
+          return '' unless entry
+
+          # Build entry attributes
+          attrs = build_attributes(entry)
+
+          # Get entry ID from metadata
+          entry_id = entry.metadata&.dig(:anchor_name) || entry.metadata&.dig(:document_id) || entry.id
+
+          # Build anchor if ID present
+          anchor_html = if entry_id
+                          %(<a id="#{escape_attribute(entry_id)}" class="bibliography-anchor"></a>)
+                        else
+                          ''
+                        end
+
+          # Get citation label
+          label = entry.metadata&.dig(:label) || entry_id || ''
+
+          # Get entry reference text
+          content = entry.content || ''
+
+          # Process content
+          content_html = process_content(content)
+
+          # Combine into entry
+          entry_html = anchor_html
+          entry_html += %(<span class="bibliography-label">#{escape_html(label)}</span> ) unless label.empty?
+          entry_html += content_html
+
+          %(<div#{attrs}>#{entry_html}</div>)
+        end
+
+        # Convert HTML bibliography entry to CoreModel::Block (bibliography entry)
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'div'
+          return nil unless element['class']&.include?('bibliography-entry')
+
+          # Extract anchor/ID
+          anchor = element.at_css('.bibliography-anchor, a[id]')
+          entry_id = anchor&.[]('id')
+
+          # Extract label
+          label_elem = element.at_css('.bibliography-label')
+          label = label_elem&.text&.strip
+
+          # Extract content (everything except anchor and label)
+          content_nodes = element.children.reject do |node|
+            node == anchor || node == label_elem || (node.text? && node.text.strip.empty?)
+          end
+
+          content = extract_content(content_nodes)
+
+          Coradoc::CoreModel::Block.new(
+            element_type: 'bibliography_entry',
+            content: content,
+            id: entry_id,
+            metadata: {
+              label: label
+            }
+          )
+        end
+
+        def self.build_attributes(_entry)
+          %( class="bibliography-entry")
+        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
+          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_content(nodes)
+          # Extract and convert content nodes
+          nodes.map do |node|
+            if node.text?
+            end
+            node.text
+          end.compact.join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Image (block image)
+      class BlockImage < Base
+        def self.to_html(model, _state = {})
+          img_attrs = {}
+          # Remove leading colons from src (source format syntax artifact)
+          src = model.src
+          src = src.sub(/^:+/, '') if src
+          img_attrs[:src] = src if src
+          img_attrs[:id] = model.id if model.id
+          img_attrs[:alt] = model.alt || model.caption || ''
+
+          # Extract additional attributes
+          img_attrs[:width] = model.width if model.width
+          img_attrs[:height] = model.height if model.height
+
+          img_element = build_element('img', nil, img_attrs)
+
+          # Wrap in figure if we have a caption
+          if model.caption && !model.caption.empty?
+            figcaption = build_element('figcaption', model.caption)
+            content = "#{img_element}\n#{figcaption}"
+            build_element('figure', "\n#{content}\n")
+          else
+            # Just a plain img element wrapped in a div for block display
+            build_element('div', img_element, { class: 'image' })
+          end
+        end
+
+        def self.to_coradoc(node, _state = {})
+          # Handle both <figure> and <div class="image"> cases
+          if node.name == 'figure'
+            img_node = node.at_css('img')
+            return nil unless img_node
+
+            attrs = extract_attributes(img_node)
+            figcaption = node.at_css('figcaption')
+            caption = figcaption&.text
+
+            Coradoc::CoreModel::Image.new(
+              src: attrs[:src],
+              id: attrs[:id],
+              caption: caption,
+              alt: attrs[:alt],
+              width: attrs[:width],
+              height: attrs[:height],
+              inline: false
+            )
+          elsif node.name == 'div' && node['class'] == 'image'
+            img_node = node.at_css('img')
+            return nil unless img_node
+
+            attrs = extract_attributes(img_node)
+
+            Coradoc::CoreModel::Image.new(
+              src: attrs[:src],
+              id: attrs[:id],
+              alt: attrs[:alt],
+              width: attrs[:width],
+              height: attrs[:height],
+              inline: false
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Bold inline element
+      class Bold < Base
+        class << self
+          # Convert HTML <strong> or <b> to CoreModel::InlineElement
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::InlineElement] Bold inline element
+          def to_coradoc(node, state = {})
+            content = treat_children(node, state)
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: 'bold',
+              content: content
+            )
+          end
+
+          # Convert CoreModel::InlineElement (bold) to HTML <strong>
+          # @param model [Coradoc::CoreModel::InlineElement] Bold 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('strong', content, attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Break (horizontal rule)
+      class Break < Base
+        class << self
+          # Convert HTML <hr> to CoreModel::InlineElement (break)
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::InlineElement] Break inline element
+          def to_coradoc(_node, _state = {})
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: 'break',
+              metadata: { break_type: 'thematic' }
+            )
+          end
+
+          # Convert CoreModel::InlineElement (break) to HTML <hr>
+          # @param model [Coradoc::CoreModel::InlineElement] Break model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, _state = {})
+            attributes = extract_model_attributes(model)
+            build_element('hr', nil, attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block with element_type "comment"
+      class CommentBlock < Base
+        # Convert CoreModel::Block (comment) to HTML comment
+        def self.to_html(comment_block, options = {})
+          return '' unless comment_block
+
+          # Check if comments should be preserved
+          return '' unless options[:preserve_comments]
+
+          # Get comment text (CoreModel::Block has content attribute)
+          text = comment_block.content.to_s
+
+          # HTML comments cannot contain --
+          # Replace -- with - - to avoid breaking the comment
+          safe_text = text.gsub('--', '- -')
+
+          # Preserve newlines in comment block
+          # Multi-line comment blocks should preserve their internal newlines
+          "<!--\n#{escape_html(safe_text)}\n-->"
+        end
+
+        # Convert HTML comment to CoreModel::Block (comment)
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.comment?
+
+          # Extract comment text
+          text = element.text.to_s
+
+          Coradoc::CoreModel::Block.new(
+            element_type: 'comment',
+            content: text
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class CommentLine < Base
+        # Convert CoreModel to HTML comment
+        def self.to_html(comment, options = {})
+          return '' unless comment
+
+          # Check if comments should be preserved
+          return '' unless options[:preserve_comments]
+
+          # Get comment text - check for content or text attribute
+          text = if comment.content
+                   comment.content
+                 elsif comment.text
+                   comment.text
+                 else
+                   ''
+                 end
+
+          text = text.to_s
+
+          # HTML comments cannot contain --
+          # Replace -- with - - to avoid breaking the comment
+          safe_text = text.gsub('--', '- -')
+
+          # Preserve newlines in comment text
+          # Empty comments (just "//") should become newlines in HTML comments
+          if safe_text.strip.empty?
+            "<!--\n-->"
+          else
+            "<!-- #{escape_html(safe_text)} -->"
+          end
+        end
+
+        # Convert HTML comment to CoreModel
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.comment?
+
+          # Extract comment text
+          text = element.text.to_s.strip
+
+          # For now, return an InlineElement with special format_type for comment
+          Coradoc::CoreModel::InlineElement.new(
+            format_type: 'comment',
+            content: text
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::InlineElement with format_type "xref"
+      class CrossReference < Base
+        class << self
+          # Convert CoreModel::InlineElement (xref) to HTML
+          # @param model [Coradoc::CoreModel::InlineElement] CrossReference model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML anchor tag
+          def to_html(model, _state = {})
+            href = model.target.to_s
+            # Create anchor link to internal reference
+            # Format: <a href="#section-id">section-id</a> or with text from content
+            text = if model.content&.to_s&.strip != ''
+                     model.content.to_s
+                   else
+                     href
+                   end
+
+            # Ensure href starts with # for internal links
+            link_href = href.start_with?('#') ? href : "##{href}"
+
+            %(<a href="#{escape_attribute(link_href)}">#{escape_html(text)}</a>)
+          end
+
+          # Convert HTML anchor to CoreModel::InlineElement (xref)
+          # @param node [Nokogiri::XML::Node] HTML anchor node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::InlineElement] CrossReference model
+          def to_coradoc(node, _state = {})
+            href = node['href'].to_s
+            text = node.text.strip
+
+            # Only treat internal links as cross-references
+            if href.start_with?('#')
+              ref_id = href[1..] # Remove leading #
+              content = text.empty? || text == ref_id ? nil : text
+              Coradoc::CoreModel::InlineElement.new(
+                format_type: 'xref',
+                target: ref_id,
+                content: content
+              )
+            else
+              # External links become regular links
+              Coradoc::CoreModel::InlineElement.new(
+                format_type: 'link',
+                target: href,
+                content: text
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Document
+      class Document < Base
+        class << self
+          # Convert HTML document to CoreModel::StructuralElement
+          # @param node [Nokogiri::XML::Document, Nokogiri::XML::Node] HTML document or article node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::StructuralElement] Document model
+          def to_coradoc(node, state = {})
+            # Find the main content area
+            body = find_body_content(node)
+
+            # Extract document metadata
+            metadata = extract_metadata(node, state)
+
+            # Process body content
+            content = treat_children(body, state)
+
+            # Create document
+            doc = Coradoc::CoreModel::StructuralElement.new(
+              element_type: 'document',
+              title: metadata[:title],
+              children: content
+            )
+
+            # Store author in metadata if present
+            doc.metadata = (doc.metadata || {}).merge(author: metadata[:author]) if metadata[:author]
+
+            doc
+          end
+
+          # Convert CoreModel::StructuralElement to HTML
+          # @param model [Coradoc::CoreModel::StructuralElement] Document model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, state = {})
+            # Handle CoreModel::StructuralElement
+            return convert_core_model_document(model, state) if model.is_a?(Coradoc::CoreModel::StructuralElement)
+
+            # Fallback for other types
+            ''
+          end
+
+          # Convert CoreModel::StructuralElement to HTML
+          # @param model [Coradoc::CoreModel::StructuralElement] CoreModel document
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def convert_core_model_document(model, state = {})
+            parts = []
+
+            # Add title if present
+            if model.title
+              title_text = model.title.is_a?(String) ? model.title : model.title.to_s
+              parts << build_element('h1', title_text) unless title_text.empty?
+            end
+
+            # Convert children
+            model.children&.each do |child|
+              html = convert_content_to_html(child, state)
+              parts << html if html && !html.empty?
+            end
+
+            # Wrap in article tag with id="content" for CSS styling
+            content = parts.join("\n")
+            attributes = { id: 'content' }
+            attributes[:id] = model.id if model.id
+            build_element('article', content, attributes)
+          end
+
+          private
+
+          # Find the body content in HTML document
+          def find_body_content(node)
+            case node
+            when Nokogiri::HTML::Document
+              node.at('body') || node.at('article') || node.root
+            when Nokogiri::XML::Document
+              node.at('body') || node.at('article') || node.root
+            else
+              node
+            end
+          end
+
+          # Extract document metadata from HTML
+          def extract_metadata(node, _state)
+            metadata = { attributes: {} }
+
+            # Extract title from <title> or <h1> (node is Nokogiri::XML::Node or Document)
+            if node.is_a?(Nokogiri::XML::Document) || node.is_a?(Nokogiri::XML::Node)
+              title_node = node.at('title') || node.at('h1')
+              metadata[:title] = title_node.text.strip if title_node
+
+              # Extract author from meta tag
+              author_meta = node.at('meta[name="author"]')
+              metadata[:author] = author_meta['content'] if author_meta
+            end
+
+            metadata
+          end
+        end
+      end
+    end
+  end
+end