coradoc-html 1.1.7

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'coradoc/html/template_renderer'
+
+module Coradoc
+  module Html
+    module Converters
+      # HTML converter that uses Liquid templates for rendering
+      #
+      # This converter provides template-based rendering where:
+      # - Users can provide custom template directories
+      # - Falls back to default templates
+      # - Supports template inheritance
+      #
+      # @example Basic usage
+      #   renderer = TemplateHtmlConverter.new(template_paths: ["/my/templates"])
+      #   html = renderer.render(document)
+      #
+      class TemplateHtmlConverter < Base
+        # Initialize the converter
+        #
+        # @param template_paths [Array<String>] Custom template directories
+        # @param options [Hash] Additional options
+        def initialize(template_paths: [], options: {})
+          @template_paths = template_paths
+          @options = options
+          @renderer = nil
+        end
+
+        # Get or create the template renderer
+        #
+        # @return [Coradoc::Html::TemplateRenderer] The renderer
+        def renderer
+          @renderer ||= Coradoc::Html::TemplateRenderer.new(
+            template_paths: @template_paths,
+            options: @options
+          )
+        end
+
+        # Render a CoreModel document to HTML
+        #
+        # @param model [Coradoc::CoreModel::Base] The document to render
+        # @param state [Hash] Rendering state
+        # @return [String] Rendered HTML
+        def self.to_html(model, state = {})
+          # Get template_paths from state or use defaults
+          template_paths = state[:template_paths] || []
+
+          # Create converter with template paths
+          new(template_paths: template_paths, options: state[:template_options] || {})
+
+          # Convert content using template renderer
+          convert_content_to_html(model, state)
+        end
+
+        # Convert content to HTML using template renderer
+        #
+        # @param content [Object] Content to convert
+        # @param state [Hash] Conversion state
+        # @return [String] HTML string
+        def self.convert_content_to_html(content, state = {})
+          return '' if content.nil?
+
+          renderer = Coradoc::Html::TemplateRenderer.new(
+            template_paths: state[:template_paths] || [],
+            options: state[:template_options] || {}
+          )
+
+          renderer.render(content)
+        end
+
+        # Render a CoreModel document to HTML using the template renderer
+        #
+        # @param model [Coradoc::CoreModel::Base] The document to render
+        # @param state [Hash] Rendering state
+        # @return [String] Rendered HTML
+        def self.render_with_templates(model, state = {})
+          renderer = Coradoc::Html::TemplateRenderer.new(
+            template_paths: state[:template_paths] || [],
+            options: state[:template_options] || {}
+          )
+
+          renderer.render(model)
+        end
+      end
+
+      # Helper module for rendering CoreModel elements using templates
+      module TemplateHelpers
+        # Render a CoreModel element using templates
+        #
+        # @param element [Coradoc::CoreModel::Base] Element to render
+        # @param template_paths [Array<String>] Custom template directories
+        # @param options [Hash] Template options
+        # @return [String] Rendered HTML
+        def render_with_templates(element, template_paths: [], **options)
+          renderer = Coradoc::Html::TemplateRenderer.new(
+            template_paths: template_paths,
+            options: options
+          )
+          renderer.render(element)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      autoload :Base, "#{__dir__}/base"
+      # Converter for CoreModel::InlineElement (term) elements
+      #
+      # Terms are used in definition lists and can have types like "acronym",
+      # "symbol", "preferred", etc.
+      class Term < Base
+        # Convert HTML to CoreModel::InlineElement (term)
+        def self.to_coradoc(node, _state = {})
+          attrs = extract_node_attributes(node)
+
+          term_text = node.text.strip
+          term_type = attrs[:'data-term-type'] || attrs[:class]&.split&.find do |c|
+            c.start_with?('term-')
+          end&.sub('term-', '')
+
+          Coradoc::CoreModel::InlineElement.new(
+            format_type: 'term',
+            content: term_text,
+            target: term_type || 'term',
+            metadata: {
+              lang: attrs[:lang] || 'en',
+              render_text: attrs[:'data-render-text']
+            }
+          )
+        end
+
+        # Convert CoreModel::InlineElement (term) to HTML
+        def self.to_html(term, _state = {})
+          term_text = term.content || ''
+          term_type = term.target || 'term'
+          render_text = term.metadata&.dig(:render_text)
+
+          # Use render_text if available, otherwise use term
+          display_text = render_text&.strip&.empty? ? false : render_text
+          display_text ||= term_text
+
+          # Build class attribute
+          classes = ['term', "term-#{escape_attribute(term_type)}"]
+          class_attr = classes.join(' ')
+
+          # Build data attributes
+          data_attrs = []
+          data_attrs << %( data-term-ref="#{escape_attribute(term_text)}")
+          lang = term.metadata&.dig(:lang)
+          data_attrs << %( lang="#{escape_attribute(lang)}") if lang && lang != 'en'
+
+          # Render as a styled span with term reference
+          %(<span class="#{class_attr}"#{data_attrs.join}>#{escape_html(display_text)}</span>)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for TextElement (plain text content)
+      # In CoreModel, text is handled as plain strings
+      class TextElement < Base
+        class << self
+          # Convert HTML text node to String
+          # @param node [Nokogiri::XML::Node, String] HTML text node or string
+          # @param state [Hash] Conversion state
+          # @return [String] Plain text
+          def to_coradoc(node, state = {})
+            text = node.is_a?(String) ? node : node.text
+            text = unescape_html(text) unless state[:skip_unescape]
+            text
+          end
+
+          # Convert CoreModel content to HTML
+          # @param model [String, CoreModel] Text content
+          # @param state [Hash] Conversion state
+          # @return [String] Plain text (escaped)
+          def to_html(model, state = {})
+            # Handle both string and model with content attribute
+            content = model.content || model
+
+            return '' if content.nil?
+
+            # Process content based on type
+            case content
+            when String
+              escape_html(content)
+            when Array
+              content.map { |item| convert_content_to_html(item, state) }.join
+            else
+              escape_html(content.to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for Unordered (bulleted) lists
+      class Unordered < Base
+        class << self
+          # Convert HTML <ul> to CoreModel::ListBlock
+          # @param node [Nokogiri::XML::Node] HTML node
+          # @param state [Hash] Conversion state
+          # @return [Coradoc::CoreModel::ListBlock] Unordered 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: 'unordered',
+              items: items
+            )
+            list.id = attrs[:id] if attrs[:id]
+
+            list
+          end
+
+          # Convert CoreModel::ListBlock (unordered) to HTML <ul>
+          # @param model [Coradoc::CoreModel::ListBlock] Unordered 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
+
+            build_element('ul', "\n#{items_html}\n", attrs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for CoreModel::Block (verse) to HTML <div class="verse">
+      class Verse < Base
+        # Convert CoreModel::Block (verse) to HTML <div class="verse">
+        def self.to_html(verse, _options = {})
+          return '' unless verse
+
+          # Build div attributes
+          attrs = build_attributes(verse)
+
+          # Build title if present
+          title_html = build_title(verse)
+
+          # Build attribution if present
+          attribution = build_attribution(verse)
+
+          # Process verse content - preserve line breaks
+          content = process_content(verse.content)
+
+          # Combine title, content, and attribution
+          verse_html = ''
+          verse_html += "#{title_html}\n" if title_html
+          verse_html += %(<pre class="verse-content">#{content}</pre>)
+          verse_html += "\n#{attribution}" if attribution
+
+          %(<div#{attrs}>\n#{verse_html}\n</div>)
+        end
+
+        # Convert HTML <div class="verse"> to CoreModel::Block (verse)
+        def self.to_coradoc(element, _options = {})
+          return nil unless element.name == 'div'
+          return nil unless element['class']&.include?('verse')
+
+          # Extract title if present
+          title_elem = element.at_css('.verse-title')
+          title = title_elem&.text&.strip
+
+          # Extract content from <pre class="verse-content">
+          content_elem = element.at_css('.verse-content, pre')
+          content = content_elem&.text || ''
+
+          # 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::VerseBlock.new(
+            content: content,
+            title: title,
+            id: id,
+            attribution: attribution
+          )
+        end
+
+        def self.build_attributes(verse)
+          attrs = [%( class="verse")]
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(verse.id)}") if verse.id
+
+          attrs.join
+        end
+
+        def self.build_title(verse)
+          return nil unless verse.title
+
+          title_text = verse.title.to_s
+          return nil if title_text.empty?
+
+          %(<div class="verse-title">#{escape_html(title_text)}</div>)
+        end
+
+        def self.build_attribution(verse)
+          attribution_text = verse.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.process_content(content)
+          return '' if content.nil?
+
+          # For verse, preserve the content as-is with line breaks
+          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/video.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Converters
+      # Converter for video elements
+      class Video < Base
+        # Convert CoreModel::Block (video) to HTML <video>
+        def self.to_html(video, _options = {})
+          return '' unless video
+
+          # Build video attributes
+          attrs = build_attributes(video)
+
+          # Get video source from metadata or content
+          src = video.metadata&.dig(:src) || video.content
+
+          # Build source element
+          source_tag = %(<source src="#{escape_attribute(src)}"#{build_type_attr(src)}>)
+
+          # Build optional caption/title
+          caption = video.title
+
+          # Determine if we need a wrapper (for block video with caption)
+          if caption
+            <<~HTML.strip
+              <figure#{build_figure_attrs(video)}>
+                <video#{attrs}>
+                  #{source_tag}
+                  Your browser does not support the video tag.
+                </video>
+                <figcaption>#{escape_html(caption)}</figcaption>
+              </figure>
+            HTML
+          else
+            <<~HTML.strip
+              <video#{attrs}>
+                #{source_tag}
+                Your browser does not support the video tag.
+              </video>
+            HTML
+          end
+        end
+
+        # Convert HTML <video> to CoreModel::Block (video)
+        def self.to_coradoc(element, _options = {})
+          # Handle both <video> and <figure><video> structures
+          video_elem = if element.name == 'figure'
+                         element.at_css('video')
+                       elsif element.name == 'video'
+                         element
+                       else
+                         return nil
+                       end
+
+          return nil unless video_elem
+
+          # Extract source from <source> tag or src attribute
+          src = extract_video_src(video_elem)
+          return nil unless src
+
+          # Extract caption if in figure
+          caption = if element.name == 'figure'
+                      figcaption = element.at_css('figcaption')
+                      figcaption&.text&.strip
+                    end
+
+          # Extract ID if present
+          id = video_elem['id'] || element['id']
+
+          # Extract video attributes
+          metadata = extract_video_metadata(video_elem)
+          metadata[:src] = src
+
+          Coradoc::CoreModel::Block.new(
+            element_type: 'video',
+            content: src,
+            title: caption,
+            id: id,
+            metadata: metadata
+          )
+        end
+
+        def self.build_attributes(video)
+          attrs = []
+
+          # Extract options from metadata
+          options = video.metadata&.dig(:options) || []
+
+          # Add controls by default (unless nocontrols option is set)
+          has_controls = !options.include?('nocontrols')
+          attrs << ' controls' if has_controls
+
+          # Add autoplay if specified in options
+          attrs << ' autoplay' if options.include?('autoplay')
+
+          # Add loop if specified in options
+          attrs << ' loop' if options.include?('loop')
+
+          # Add muted if specified in options
+          attrs << ' muted' if options.include?('muted')
+
+          # Add poster if specified
+          poster = video.metadata&.dig(:poster)
+          attrs << %( poster="#{escape_attribute(poster)}") if poster
+
+          # Add width and height if specified
+          width = video.metadata&.dig(:width)
+          height = video.metadata&.dig(:height)
+
+          attrs << %( width="#{escape_attribute(width)}") if width
+
+          attrs << %( height="#{escape_attribute(height)}") if height
+
+          # Add ID if present
+          attrs << %( id="#{escape_attribute(video.id)}") if video.id
+
+          attrs.join
+        end
+
+        def self.build_type_attr(src)
+          # Determine video MIME type from extension
+          ext = File.extname(src).downcase
+          type = case ext
+                 when '.mp4'
+                   'video/mp4'
+                 when '.webm'
+                   'video/webm'
+                 when '.ogg', '.ogv'
+                   'video/ogg'
+                 end
+
+          type ? %( type="#{type}") : ''
+        end
+
+        def self.build_figure_attrs(video)
+          attrs = []
+
+          # Add ID to figure if present
+          attrs << %( id="#{escape_attribute(video.id)}-figure") if video.id
+
+          attrs.join
+        end
+
+        def self.extract_video_src(element)
+          # Try to get src from <source> tag first
+          source = element.at_css('source')
+          return source['src'] if source && source['src']
+
+          # Fall back to src attribute on <video>
+          element['src']
+        end
+
+        def self.extract_video_metadata(element)
+          metadata = {}
+          options = []
+
+          # Extract boolean attributes
+          options << 'controls' if element.has_attribute?('controls')
+          options << 'autoplay' if element.has_attribute?('autoplay')
+          options << 'loop' if element.has_attribute?('loop')
+          options << 'muted' if element.has_attribute?('muted')
+
+          metadata[:options] = options unless options.empty?
+
+          # Extract poster
+          metadata[:poster] = element['poster'] if element['poster']
+
+          # Extract dimensions
+          metadata[:width] = element['width'] if element['width']
+
+          metadata[:height] = element['height'] if element['height']
+
+          metadata
+        end
+      end
+    end
+  end
+end