coradoc-html 1.1.7 → 1.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef32c1399675f7e55b4ab77c56dd992b246c0f5fc0d42f027a4792c35b67ed05
-  data.tar.gz: be81a3f8b9baa8dd31515bfeb32b134761271e4066d53cbeb57856a6735a4c77
+  metadata.gz: d86ee1dfe0630fc0923c8bbaaf53a3a9653faf3a90f3fa6760e2abe765cc46a3
+  data.tar.gz: 228cb361cb1b9a7dc64823788fac88afa87e5d972049064ffdd51d9909ad11a4
 SHA512:
-  metadata.gz: 7e2696c2a2e80fb3059881b2ef7a4dbd124f8ca252b1b2fed68590324ae7d875c0d178349647be091547cf7d9143b64b75286abd55a5059dd8d91e15aff55715
-  data.tar.gz: 5ccdc1ff38c8c851f0923deebddbe933488820738a6fb2faa1ed02d3262ca559e41d0c0d9b85e4fb5954a7809cf18ff7b1158dc960f5bfa973404c3749edbdda
+  metadata.gz: c219dbf71096377f684cd4ac7888e63248f1bf0ae279aec7e64923a1188bab59e57db330f4582cf5801155f2bfd061746c88dc4e61d79550130782459fd4b5e5
+  data.tar.gz: db6bb17213127a330405a09785ae40a54c45c7ebfa5cf4f00709efeffe0534827401aa502e9fb10a3c6ab51c17cf257ad3129ffa7650d53c5a6f64c141954f50

data/lib/coradoc/html/config.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require 'nokogiri'
+
 module Coradoc
   module Html
-    # HTML configuration and options
     module Config
+      DEFAULT_LANG = 'en'
+      DEFAULT_TITLE = 'Untitled'
+
       # Default HTML output options
       DEFAULT_OPTIONS = {
         # Theme system options
@@ -225,7 +229,11 @@ module Coradoc
         # Build CSS link tag
         def css_link_tag(options = {})
           href = stylesheet_path(options)
-          %(<link rel="stylesheet" href="#{href}">)
+          doc = Nokogiri::HTML::Document.new
+          node = Nokogiri::XML::Node.new('link', doc)
+          node['rel'] = 'stylesheet'
+          node['href'] = href
+          node.to_html
         end
 
         # Build CSS style tag with embedded content
@@ -236,14 +244,14 @@ module Coradoc
           content = css_content
           content += "\n\n#{custom_css}" if custom_css && !custom_css.empty?
 
-          %(<style>\n#{content}\n</style>)
+          build_text_element('style', content)
         end
 
         # Build custom CSS style tag
         def custom_css_tag(custom_css)
           return '' unless custom_css && !custom_css.empty?
 
-          %(<style>\n#{custom_css}\n</style>)
+          build_text_element('style', custom_css)
         end
 
         # Determine whether to embed or link CSS
@@ -305,7 +313,11 @@ module Coradoc
         # Build JavaScript link tag
         def js_link_tag(options = {})
           src = javascript_path(options)
-          %(<script src="#{src}" defer></script>)
+          doc = Nokogiri::HTML::Document.new
+          node = Nokogiri::XML::Node.new('script', doc)
+          node['src'] = src
+          node['defer'] = ''
+          node.to_html
         end
 
         # Build JavaScript script tag with embedded content
@@ -313,7 +325,7 @@ module Coradoc
           js_content = embedded_javascript(options)
           return '' if js_content.empty?
 
-          %(<script>\n#{js_content}\n</script>)
+          build_text_element('script', js_content)
         end
 
         # Build complete JavaScript tags (link or embedded)
@@ -378,14 +390,19 @@ module Coradoc
         # @return [String] HTML tags for Highlight.js
         def highlightjs_tags(options = {})
           theme = options[:highlightjs_theme] || DEFAULT_OPTIONS[:highlightjs_theme]
-          tags = []
+          doc = Nokogiri::HTML::Document.new
 
-          # Add Highlight.js library
-          tags << %(<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/#{theme}.min.css">)
-          tags << %(<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>)
-          tags << %(<script>hljs.highlightAll();</script>)
+          link_node = Nokogiri::XML::Node.new('link', doc)
+          link_node['rel'] = 'stylesheet'
+          link_node['href'] = "https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/#{theme}.min.css"
 
-          tags.join("\n")
+          script_node = Nokogiri::XML::Node.new('script', doc)
+          script_node['src'] = 'https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js'
+
+          init_node = Nokogiri::XML::Node.new('script', doc)
+          init_node.content = 'hljs.highlightAll();'
+
+          [link_node.to_html, script_node.to_html, init_node.to_html].join("\n")
         end
 
         # Get data attributes for code block
@@ -461,6 +478,13 @@ module Coradoc
           line_break: 'br',
           admonition: 'div'
         }.freeze
+
+        def build_text_element(tag_name, content)
+          doc = Nokogiri::HTML::Document.new
+          node = Nokogiri::XML::Node.new(tag_name, doc)
+          node.content = content
+          node.to_html
+        end
       end
     end
   end

data/lib/coradoc/html/converter_base.rb

@@ -23,6 +23,21 @@ module Coradoc
       # Error class for unsupported document types
       class UnsupportedDocumentError < Coradoc::Error; end
 
+      # Base class for output converter configurations.
+      #
+      # Provides shared `merge` and `defaults` patterns.
+      # Subclasses define `initialize`, `to_h`, and `validate!`.
+      class ConfigurationBase
+        def self.defaults
+          new
+        end
+
+        def merge(other)
+          other_hash = other.is_a?(self.class) ? other.to_h : other.to_h.transform_keys(&:to_sym)
+          self.class.new(**to_h, **other_hash)
+        end
+      end
+
       attr_reader :document, :config
 
       # Initialize a new converter instance
@@ -80,24 +95,8 @@ module Coradoc
         new(document, config).to_file(output_path)
       end
 
-      # Get the converter name
-      #
-      # @return [Symbol] Converter name (e.g., :static, :spa)
-      def converter_name
-        @converter_name ||= self.class.name.split('::').last
-                                .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-                                .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                                .downcase
-                                .to_sym
-      end
-
       protected
 
-      # Validate the input document
-      #
-      # @param document [Object] The document to validate
-      # @return [Coradoc::CoreModel::Base] The validated document
-      # @raise [UnsupportedDocumentError] if document is not valid
       def validate_input(document)
         # Handle transformer hash output
         document = Coradoc::Transformer.transform(document) if document.is_a?(Hash) && document.key?(:document)
@@ -113,64 +112,23 @@ module Coradoc
         document
       end
 
-      # Build configuration from options
-      #
-      # @param config [Hash, Object] Configuration options or object
-      # @return [Object] Built configuration object
       def build_config(config)
-        if config.public_methods.include?(:validate!)
-          config.validate!
-          return config
-        end
+        klass = configuration_class
+        return config unless klass
 
-        config
-      end
-
-      def extract_document_title
-        if @document.is_a?(Coradoc::CoreModel::StructuralElement) && @document.title
-          title = @document.title
-          return title if title.is_a?(String)
-          return title.text if title.is_a?(Coradoc::CoreModel::Base) && title.text
-
-          return title.to_s
-        end
-
-        'Untitled Document'
-      end
-
-      def extract_text_from_content(content)
-        case content
-        when Array
-          content.map { |item| extract_text_from_content(item) }.join
-        when String
-          content
-        when Coradoc::CoreModel::InlineElement
-          content.content.to_s
-        when Coradoc::CoreModel::Base
-          if content.content
-            extract_text_from_content(content.content)
-          else
-            content.to_s
-          end
+        case config
+        when klass
+          config.validate!
+          config
+        when Hash
+          klass.new(**config)
         else
-          content.to_s
+          klass.defaults
         end
       end
 
-      # Escape HTML content
-      #
-      # @param text [String] Text to escape
-      # @return [String] Escaped text
-      def escape_html(text)
-        Coradoc::Html::Base.escape_html(text.to_s)
-      end
-
-      # Escape HTML attribute value
-      #
-      # @param value [String] Value to escape
-      # @return [String] Escaped value
-      def escape_attr(value)
-        value.to_s.gsub('"', '&quot;').gsub('<', '&lt;').gsub('>', '&gt;')
+      def configuration_class
+        nil
       end
     end
   end

data/lib/coradoc/html/drop/annotation_drop.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class AnnotationDrop < Base
+        def template_type
+          'annotation_block'
+        end
+
+        def annotation_type
+          (@model.annotation_type || 'note').to_s.downcase
+        end
+
+        def label
+          Escape.escape_html(@model.annotation_label || annotation_type.upcase)
+        end
+
+        def content
+          content_to_liquid(@model.renderable_content)
+        end
+
+        def css_class
+          "admonitionblock #{annotation_type}"
+        end
+      end
+
+      DropFactory.register(CoreModel::AnnotationBlock, AnnotationDrop)
+    end
+  end
+end

data/lib/coradoc/html/drop/base.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'liquid'
+
+module Coradoc
+  module Html
+    module Drop
+      class Base < Liquid::Drop
+        attr_reader :model
+
+        def initialize(model)
+          @model = model
+        end
+
+        def to_liquid
+          self
+        end
+
+        def template_type
+          self.class.name
+              .split('::').last
+              .sub(/Drop$/, '')
+              .gsub(/([A-Z])/, '_\1')
+              .downcase
+              .sub(/^_/, '')
+        end
+
+        def id
+          @model.id
+        end
+
+        def title
+          optional_text(@model.title)
+        end
+
+        protected
+
+        def optional_text(value)
+          return nil unless value && !value.to_s.empty?
+
+          Escape.escape_html(value)
+        end
+
+        def extract_text(content)
+          case content
+          when nil then ''
+          when String then content
+          when Array then content.map { |c| extract_text(c) }.join
+          when CoreModel::InlineElement
+            content.text || extract_text(content.content)
+          when CoreModel::TextContent
+            content.text.to_s
+          when CoreModel::Base
+            TitleText.resolve(content).to_s
+          else
+            content.to_s
+          end
+        end
+
+        def content_to_liquid(content)
+          DropFactory.create(content)
+        end
+
+        def children_to_liquid(children)
+          return [] unless children
+
+          children.map { |child| DropFactory.create(child) }
+        end
+      end
+    end
+  end
+end
+
+# Load DropFactory and all drops after Base is fully defined.
+# Each drop self-registers; DropFactory sorts by type specificity
+# so registration order doesn't matter.
+require_relative 'drop_factory'

data/lib/coradoc/html/drop/bibliography_drop.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class BibliographyDrop < Base
+        def entries
+          children_to_liquid(@model.entries)
+        end
+      end
+
+      DropFactory.register(CoreModel::Bibliography, BibliographyDrop)
+    end
+  end
+end

data/lib/coradoc/html/drop/bibliography_entry_drop.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class BibliographyEntryDrop < Base
+        def anchor_name
+          n = @model.anchor_name
+          n && !n.to_s.empty? ? n : nil
+        end
+
+        def document_id
+          optional_text(@model.document_id)
+        end
+
+        def ref_text
+          optional_text(@model.ref_text)
+        end
+      end
+
+      DropFactory.register(CoreModel::BibliographyEntry, BibliographyEntryDrop)
+    end
+  end
+end

data/lib/coradoc/html/drop/block_drop.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class BlockDrop < Base
+        SEMANTIC_TAG_MAP = {
+          paragraph: 'p', source_code: 'pre', quote: 'blockquote',
+          verse: 'blockquote', example: 'div', sidebar: 'aside',
+          literal: 'pre', listing: 'pre', open: 'div',
+          horizontal_rule: 'hr'
+        }.freeze
+
+        SEMANTIC_CLASS_MAP = {
+          example: 'example', sidebar: 'sidebar', literal: 'literal'
+        }.freeze
+
+        def semantic_type
+          resolved_semantic_type.to_s
+        end
+
+        def html_tag
+          SEMANTIC_TAG_MAP[resolved_semantic_type] || 'div'
+        end
+
+        def language
+          @model.language || @model.metadata('language')
+        end
+
+        def css_class
+          cls = SEMANTIC_CLASS_MAP[resolved_semantic_type]
+          cls ? "block-#{semantic_type} #{cls}" : "block-#{semantic_type}"
+        end
+
+        def content
+          content_to_liquid(@model.renderable_content)
+        end
+
+        def text
+          if %i[source_code literal listing].include?(resolved_semantic_type)
+            Escape.escape_html(@model.flat_text)
+          elsif resolved_semantic_type == :pass
+            @model.flat_text.to_s
+          end
+        end
+
+        def hidden?
+          %i[comment reviewer].include?(resolved_semantic_type)
+        end
+
+        def raw?
+          resolved_semantic_type == :pass
+        end
+
+        def hr?
+          resolved_semantic_type == :horizontal_rule
+        end
+
+        private
+
+        def resolved_semantic_type
+          @resolved_semantic_type ||= @model.resolve_semantic_type || :paragraph
+        end
+      end
+
+      DropFactory.register(CoreModel::Block, BlockDrop)
+    end
+  end
+end

data/lib/coradoc/html/drop/definition_item_drop.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class DefinitionItemDrop < Base
+        def term
+          Escape.escape_html(stripped_term)
+        end
+
+        def term_id
+          match = term_text.match(/\A\[\[([^\]]+)\]\]/)
+          match&.[](1)
+        end
+
+        def definitions
+          return [] unless @model.definitions
+
+          @model.definitions.map { |d| content_to_liquid(d) }
+        end
+
+        private
+
+        def term_text
+          @term_text ||= @model.term.to_s
+        end
+
+        def stripped_term
+          term_text.sub(/\A\[\[[^\]]+\]\]/, '')
+        end
+      end
+
+      DropFactory.register(CoreModel::DefinitionItem, DefinitionItemDrop)
+    end
+  end
+end

data/lib/coradoc/html/drop/definition_list_drop.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class DefinitionListDrop < Base
+        def items
+          children_to_liquid(@model.items)
+        end
+      end
+
+      DropFactory.register(CoreModel::DefinitionList, DefinitionListDrop)
+    end
+  end
+end

data/lib/coradoc/html/drop/document_drop.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class DocumentDrop < Base
+        include SectionNumberable
+
+        def template_type
+          return 'document' if @model.is_a?(CoreModel::DocumentElement)
+
+          'section'
+        end
+
+        def title
+          text = TitleText.resolve(@model.title)
+          return nil unless text && !text.empty?
+
+          if @section_number
+            Escape.escape_html("#{@section_number}. #{text}")
+          else
+            Escape.escape_html(text)
+          end
+        end
+
+        def children
+          children_to_liquid(@model.children)
+        end
+
+        def structural_type
+          case @model
+          when CoreModel::DocumentElement then 'document'
+          when CoreModel::SectionElement then 'section'
+          when CoreModel::HeaderElement then 'header'
+          when CoreModel::PreambleElement then 'preamble'
+          else 'structural'
+          end
+        end
+
+        def heading_level
+          if @model.is_a?(CoreModel::SectionElement)
+            [@model.heading_level + 1, 6].min
+          else
+            1
+          end
+        end
+      end
+
+      DropFactory.register(CoreModel::StructuralElement, DocumentDrop)
+    end
+  end
+end

data/lib/coradoc/html/drop/drop_factory.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Coradoc
+  module Html
+    module Drop
+      module DropFactory
+        @registry = []
+
+        def self.register(model_class, drop_class)
+          @registry << [model_class, drop_class]
+          sort_registry!
+        end
+
+        def self.create(obj)
+          return nil if obj.nil?
+          return obj.map { |o| create(o) } if obj.is_a?(Array)
+          return Escape.escape_html(obj) if obj.is_a?(String)
+          return obj.to_s if obj.is_a?(Numeric) || obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+
+          pair = lookup_pair(obj)
+          return pair.last.new(obj) if pair
+
+          Escape.escape_html(obj.to_s)
+        end
+
+        def self.drop_class_for(model)
+          pair = lookup_pair(model)
+          pair&.last
+        end
+
+        def self.template_type_for(model)
+          drop = drop_class_for(model)
+          drop&.new(model)&.template_type
+        end
+
+        class << self
+          private
+
+          def lookup_pair(obj)
+            @registry.find { |klass, _drop_class| obj.is_a?(klass) }
+          end
+
+          def sort_registry!
+            @registry.sort_by! { |klass, _| -klass.ancestors.length }
+          end
+        end
+      end
+    end
+  end
+end
+
+# Load all drops — each self-registers with DropFactory
+require_relative 'annotation_drop'
+require_relative 'block_drop'
+require_relative 'list_block_drop'
+require_relative 'list_item_drop'
+require_relative 'table_drop'
+require_relative 'table_row_drop'
+require_relative 'table_cell_drop'
+require_relative 'image_drop'
+require_relative 'inline_element_drop'
+require_relative 'bibliography_entry_drop'
+require_relative 'bibliography_drop'
+require_relative 'toc_entry_drop'
+require_relative 'toc_drop'
+require_relative 'definition_item_drop'
+require_relative 'definition_list_drop'
+require_relative 'term_drop'
+require_relative 'footnote_drop'
+require_relative 'text_content_drop'
+require_relative 'document_drop'

data/lib/coradoc/html/drop/footnote_drop.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    module Drop
+      class FootnoteDrop < Base
+        def footnote_id
+          @model.id || ''
+        end
+
+        def content
+          Escape.escape_html(extract_text(@model.content || @model.inline_content))
+        end
+
+        def inline?
+          footnote_id.empty?
+        end
+      end
+
+      DropFactory.register(CoreModel::FootnoteReference, FootnoteDrop)
+      DropFactory.register(CoreModel::Footnote, FootnoteDrop)
+    end
+  end
+end