coradoc-html 1.1.7

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (example) to HTML <div class="example">
+      class Example < Base
+        # Convert CoreModel::Block (example) to HTML <div class="example">
+        def self.to_html(example, _options = {})
+          return '' unless example
+
+          # Build div attributes
+          attrs = build_attributes(example)
+
+          # Build title if present
+          title_html = build_title(example)
+
+          # Process example content
+          content = process_content(example.content)
+
+          # Combine title and content
+          example_html = ''
+          example_html += "#{title_html}\n" if title_html
+          example_html += content
+
+          %(<div#{attrs}>\n#{example_html}\n</div>)
+        end
+
+        # Convert HTML <div class="example"> to CoreModel::Block (example)
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'div'
+          return nil unless element['class']&.include?('example')
+
+          # Extract title if present
+          title_elem = element.at_css('.example-title')
+          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::ExampleBlock.new(
+            content: content,
+            title: title,
+            id: id
+          )
+        end
+
+        def self.build_attributes(example)
+          attrs = [%( class="example")]
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(example.id)}") if example.id
+
+          attrs.join
+        end
+
+        def self.build_title(example)
+          return nil unless example.title
+
+          title_text = example.title.to_s
+          return nil if title_text.empty?
+
+          %(<div class="example-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

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

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

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for include directives
+      class Include < Base
+        # Convert CoreModel::Block (include) to HTML comment with include directive
+        # Note: HTML doesn't have native include support, so we use a comment
+        def self.to_html(include_directive, _options = {})
+          return '' unless include_directive
+
+          # Get include path from metadata
+          path = include_directive.metadata&.dig(:path) || ''
+          path = escape_html(path)
+
+          # Build include directive as comment
+          comment_text = "include::#{path}[]"
+
+          # Add attributes if present
+          attrs = include_directive.metadata&.dig(:attributes) || {}
+          if attrs && !attrs.empty?
+            attrs_str = attrs.map { |k, v| "#{k}=#{v}" }.join(',')
+            comment_text = "include::#{path}[#{attrs_str}]" unless attrs_str.empty?
+          end
+
+          "<!-- #{comment_text} -->"
+        end
+
+        # Convert HTML comment with include directive to CoreModel::Block (include)
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.comment?
+
+          # Check if comment contains include directive
+          text = element.text.to_s.strip
+          return nil unless text.match?(/^include::/)
+
+          # Parse include directive
+          # Format: include::path[attributes]
+          return unless text =~ /^include::([^\[]+)(\[([^\]]*)\])?/
+
+          path = ::Regexp.last_match(1).strip
+          attrs_str = ::Regexp.last_match(3)
+
+          attrs = {}
+          if attrs_str && !attrs_str.empty?
+            # Parse attributes (simplified - doesn't handle complex cases)
+            attrs_str.split(',').each do |attr|
+              if attr.include?('=')
+                k, v = attr.split('=', 2)
+                attrs[k.strip.to_sym] = v.strip
+              end
+            end
+          end
+
+          Coradoc::CoreModel::Block.new(
+            element_type: 'include',
+            content: path,
+            metadata: {
+              path: path,
+              attributes: attrs
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Image (inline image)
+      class InlineImage < Base
+        def self.to_html(model, _state = {})
+          attrs = {}
+          # Remove leading colons from src (source format syntax artifact)
+          src = model.src
+          src = src.sub(/^:+/, '') if src
+          attrs[:src] = src if src
+          attrs[:id] = model.id if model.id
+          attrs[:alt] = model.alt || ''
+
+          # Extract additional attributes
+          attrs[:width] = model.width if model.width
+          attrs[:height] = model.height if model.height
+
+          build_element('img', nil, attrs)
+        end
+
+        def self.to_coradoc(node, _state = {})
+          return nil unless node.name == 'img'
+
+          attrs = extract_attributes(node)
+
+          Coradoc::CoreModel::Image.new(
+            src: attrs[:src],
+            id: attrs[:id],
+            alt: attrs[:alt],
+            width: attrs[:width],
+            height: attrs[:height],
+            inline: true
+          )
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for LineBreak inline element
+      class LineBreak < Base
+        class << self
+          # Convert HTML <br> to CoreModel::InlineElement (break)
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::InlineElement] LineBreak inline element
+          def to_coradoc(_node, _state = {})
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: 'break',
+              metadata: { break_type: 'line' }
+            )
+          end
+
+          # Convert CoreModel::InlineElement (break with line type) to HTML <br>
+          # @param model [Coradoc::CoreModel::InlineElement] LineBreak model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(_model, _state = {})
+            build_element('br')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      class Link < Base
+        def self.to_html(model, _state = {})
+          # Handle CoreModel::InlineElement with format_type "link"
+          attrs = {}
+          attrs[:href] = model.target if model.target
+          attrs[:id] = model.id if model.id
+
+          # Get title from metadata
+          if model.metadata && model.metadata[:title]
+            attrs[:title] =
+              model.metadata[:title]
+          end
+
+          # Determine link text - use content or target
+          text = model.content || model.target || ''
+          build_element('a', text, attrs)
+        end
+
+        def self.to_coradoc(node, _state = {})
+          return nil unless node.name == 'a'
+
+          attrs = extract_attributes(node)
+          href = attrs[:href] || ''
+          title = attrs[:title]
+          text = node.text
+
+          # If text equals href, don't set text (empty link text)
+          text = nil if text == href
+
+          Coradoc::CoreModel::InlineElement.new(
+            format_type: 'link',
+            target: href,
+            content: text,
+            metadata: { title: title }.compact,
+            id: attrs[:id]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for ListItem
+      class ListItem < Base
+        class << self
+          # Convert HTML <li> to CoreModel::ListItem
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::ListItem] ListItem model
+          def to_coradoc(node, state = {})
+            attrs = extract_node_attributes(node)
+
+            item = Coradoc::CoreModel::ListItem.new
+            item.id = attrs[:id] if attrs[:id]
+
+            # Extract content and nested lists
+            content_nodes = []
+            nested_list = nil
+
+            node.children.each do |child|
+              case child.name
+              when 'ul', 'ol'
+                # This is a nested list
+                nested_list = convert_node_to_core(child, state)
+              else
+                content_nodes << child unless child.text.strip.empty? && child.name == 'text'
+              end
+            end
+
+            # Convert content nodes - collect as mixed content array
+            if content_nodes.any?
+              content = content_nodes.flat_map { |n| convert_node_to_core(n, state) }.compact
+              # Store as children for mixed content
+              item.children = content if content.any?
+            end
+
+            item.nested = nested_list if nested_list
+
+            item
+          end
+
+          # Convert CoreModel::ListItem to HTML <li>
+          # @param model [Coradoc::CoreModel::ListItem] ListItem model
+          # @param state [Hash] Conversion state
+          # @return [String] HTML string
+          def to_html(model, state = {})
+            parts = []
+
+            # Convert main content - check children first (mixed content), then content
+            content_to_render = model.children&.any? ? model.children : model.content
+            parts << convert_content_to_html(content_to_render, state) if content_to_render
+
+            # Convert attached content
+            if model.attached && !model.attached.empty?
+              model.attached.each do |attached_item|
+                parts << convert_content_to_html(attached_item, state)
+              end
+            end
+
+            # Convert nested list
+            parts << convert_content_to_html(model.nested, state) if model.nested
+
+            attrs = {}
+            attrs[:id] = model.id if model.id
+
+            build_element('li', parts.join("\n"), attrs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (listing) to HTML <pre>
+      class Listing < Base
+        # Convert CoreModel::Block (listing) to HTML <pre>
+        def self.to_html(listing, _options = {})
+          return '' unless listing
+
+          # Build pre attributes
+          attrs = build_attributes(listing)
+
+          # Build title if present
+          title_html = build_title(listing)
+
+          # Process listing content - preserve formatting
+          content = process_content(listing.content)
+
+          # Combine title and content
+          listing_html = ''
+          listing_html += "#{title_html}\n" if title_html
+          listing_html += %(<pre#{attrs}>#{content}</pre>)
+
+          if title_html
+            %(<div class="listing-block">\n#{listing_html}\n</div>)
+          else
+            listing_html
+          end
+        end
+
+        # Convert HTML <pre> to CoreModel::Block (listing)
+        def self.to_coradoc(element, _options = {})
+          # Handle both <pre> and <div class="listing-block"><pre>
+          pre_elem = if element.name == 'div' && element['class']&.include?('listing-block')
+                       element.at_css('pre')
+                     elsif element.name == 'pre'
+                       element
+                     else
+                       return nil
+                     end
+
+          return nil unless pre_elem
+
+          # Extract title if in listing-block wrapper
+          title = if element.name == 'div'
+                    title_elem = element.at_css('.listing-title')
+                    title_elem&.text&.strip
+                  end
+
+          # Extract content
+          content = pre_elem.text
+
+          # Extract ID if present
+          id = pre_elem['id'] || element['id']
+
+          Coradoc::CoreModel::SourceBlock.new(
+            content: content,
+            title: title,
+            id: id
+          )
+        end
+
+        def self.build_attributes(listing)
+          attrs = [%( class="listing")]
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(listing.id)}") if listing.id
+
+          attrs.join
+        end
+
+        def self.build_title(listing)
+          return nil unless listing.title
+
+          title_text = listing.title.to_s
+          return nil if title_text.empty?
+
+          %(<div class="listing-title">#{escape_html(title_text)}</div>)
+        end
+
+        def self.process_content(content)
+          return '' if content.nil?
+
+          # For listing, preserve the content as-is
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (literal) to HTML <pre>
+      class Literal < Base
+        # Convert CoreModel::Block (literal) to HTML <pre>
+        def self.to_html(literal, _options = {})
+          return '' unless literal
+
+          # Build pre attributes
+          attrs = build_attributes(literal)
+
+          # Build title if present
+          title_html = build_title(literal)
+
+          # Process literal content - preserve exact formatting
+          content = process_content(literal.content)
+
+          # Combine title and content
+          literal_html = ''
+          literal_html += "#{title_html}\n" if title_html
+          literal_html += %(<pre#{attrs}>#{content}</pre>)
+
+          if title_html
+            %(<div class="literal-block">\n#{literal_html}\n</div>)
+          else
+            literal_html
+          end
+        end
+
+        # Convert HTML <pre> to CoreModel::Block (literal)
+        def self.to_coradoc(element, _options = {})
+          # Handle both <pre> and <div class="literal-block"><pre>
+          pre_elem = if element.name == 'div' && element['class']&.include?('literal-block')
+                       element.at_css('pre')
+                     elsif element.name == 'pre'
+                       # Only convert if it's a literal (no code class)
+                       return nil if element['class']&.include?('code')
+
+                       element
+                     else
+                       return nil
+                     end
+
+          return nil unless pre_elem
+
+          # Extract title if in literal-block wrapper
+          title = if element.name == 'div'
+                    title_elem = element.at_css('.literal-title')
+                    title_elem&.text&.strip
+                  end
+
+          # Extract content
+          content = pre_elem.text
+
+          # Extract ID if present
+          id = pre_elem['id'] || element['id']
+
+          Coradoc::CoreModel::LiteralBlock.new(
+            content: content,
+            title: title,
+            id: id
+          )
+        end
+
+        def self.build_attributes(literal)
+          attrs = [%( class="literal")]
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(literal.id)}") if literal.id
+
+          attrs.join
+        end
+
+        def self.build_title(literal)
+          return nil unless literal.title
+
+          title_text = literal.title.to_s
+          return nil if title_text.empty?
+
+          %(<div class="literal-title">#{escape_html(title_text)}</div>)
+        end
+
+        def self.process_content(content)
+          return '' if content.nil?
+
+          # For literal, preserve the content exactly as-is
+          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
+      end
+    end
+  end
+end

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

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