coradoc-html 1.1.7 → 1.1.13

data/lib/coradoc/html/template_config.rb

@@ -4,45 +4,32 @@ require 'pathname'
 
 module Coradoc
   module Html
-    # Configuration for the Liquid template system
+    # Configuration for the Liquid template system.
     #
-    # This class manages template directories and provides utilities
-    # for template discovery and customization.
+    # Delegates template lookup to TemplateLocator for consistent behavior
+    # across global configuration and per-renderer usage.
     #
     # @example Global configuration
     #   Coradoc::Html.configure do |config|
     #     config.template_dirs = ["/path/to/custom/templates"]
     #   end
-    #
-    # @example Per-render configuration
-    #   Coradoc::Html.serialize(document, template_dirs: ["/custom/templates"])
-    #
     class TemplateConfig
-      # Default template directory within the gem
-      DEFAULT_TEMPLATE_DIR = Pathname.new(File.join(
-                                            File.dirname(__FILE__), 'templates', 'core_model'
-                                          )).freeze
+      DEFAULT_TEMPLATE_DIR = TemplateLocator::DEFAULT_TEMPLATE_DIR
 
-      # @return [Array<Pathname>] List of user-provided template directories
       attr_accessor :template_dirs
 
-      # Initialize a new configuration
-      #
-      # @param template_dirs [Array<String, Pathname>] Custom template directories
       def initialize(template_dirs: [])
         @template_dirs = Array(template_dirs).map { |dir| Pathname.new(dir) }
       end
 
-      # Get all template directories (user + default)
-      #
-      # @return [Array<Pathname>] All template directories in search order
+      def locator
+        @locator ||= TemplateLocator.new(user_dirs: @template_dirs)
+      end
+
       def all_template_dirs
         @template_dirs + [DEFAULT_TEMPLATE_DIR]
       end
 
-      # List all available default templates
-      #
-      # @return [Array<Symbol>] List of template names (without .liquid extension)
       def self.available_templates
         @available_templates ||= begin
           return [] unless DEFAULT_TEMPLATE_DIR.exist?
@@ -54,48 +41,24 @@ module Coradoc
         end
       end
 
-      # Get the path to a specific default template
-      #
-      # @param name [Symbol, String] Template name (e.g., :bibliography)
-      # @return [Pathname, nil] Path to the template file, or nil if not found
       def self.template_path_for(name)
         path = DEFAULT_TEMPLATE_DIR.join("#{name}.liquid")
         path.exist? ? path : nil
       end
 
-      # Check if a template exists
-      #
-      # @param name [Symbol, String] Template name
-      # @return [Boolean] True if template exists in any directory
       def template_exists?(name)
-        all_template_dirs.any? do |dir|
-          dir.join("#{name}.liquid").exist?
-        end
+        locator.exists?(name.to_s)
       end
 
-      # Find a template by name
-      #
-      # @param name [Symbol, String] Template name
-      # @return [Pathname, nil] Path to the first matching template
       def find_template(name)
-        all_template_dirs.each do |dir|
-          path = dir.join("#{name}.liquid")
-          return path if path.exist?
-        end
-        nil
+        locator.find(name.to_s)
       end
 
-      # Reset configuration to defaults
-      #
-      # @return [void]
       def reset!
         @template_dirs = []
+        @locator = nil
       end
 
-      # Create a copy of this configuration with additional directories
-      #
-      # @param additional_dirs [Array<String, Pathname>] Extra directories
-      # @return [TemplateConfig] New configuration with merged directories
       def with_dirs(additional_dirs)
         self.class.new(
           template_dirs: @template_dirs + Array(additional_dirs).map { |d| Pathname.new(d) }
@@ -105,44 +68,22 @@ module Coradoc
 
     # Module-level configuration storage
     class << self
-      # Get the global configuration
-      #
-      # @return [TemplateConfig] The global configuration
       def configuration
         @configuration ||= TemplateConfig.new
       end
 
-      # Configure the template system
-      #
-      # @yield [TemplateConfig] Yields the configuration object
-      # @return [void]
-      #
-      # @example
-      #   Coradoc::Html.configure do |config|
-      #     config.template_dirs = ["/path/to/templates"]
-      #   end
       def configure
         yield(configuration) if block_given?
       end
 
-      # Reset configuration to defaults
-      #
-      # @return [void]
       def reset_configuration!
         @configuration = nil
       end
 
-      # List all available default templates
-      #
-      # @return [Array<Symbol>] List of template names
       def available_templates
         TemplateConfig.available_templates
       end
 
-      # Get the path to a default template
-      #
-      # @param name [Symbol, String] Template name
-      # @return [Pathname, nil] Path to template or nil
       def template_path_for(name)
         TemplateConfig.template_path_for(name)
       end

data/lib/coradoc/html/template_helpers.rb

@@ -6,53 +6,61 @@ module Coradoc
   module Html
     # Liquid filters for template rendering
     module TemplateFilters
-      # Render a CoreModel element by looking up its template
+      # Render a CoreModel element or Drop by looking up its template.
       #
       # Usage in templates:
       #   {{ child | render_element }}
       #   {% for item in children %}{{ item | render_element }}{% endfor %}
       #
-      def render_element(input, renderer = nil)
+      def render_element(input)
         return '' if input.nil?
-        return input.map { |i| render_element(i, renderer) }.join("\n") if input.is_a?(Array)
-
-        # Get the renderer from context registers
-        renderer ||= @context.registers[:renderer]
-
-        # If input is a Liquid::Drop, extract the original model object.
-        # Liquid::Drop stores the wrapped object as @object with no public
-        # reader — this is the only way to unwrap it.
-        original = if input.is_a?(::Liquid::Drop)
-                     input.instance_variable_get(:@object)
-                   else
-                     input
-                   end
-
-        # Renderer is always a Coradoc::Html::Renderer which has a render method
-        renderer.render(original)
+
+        renderer = @context.registers[:renderer]
+        return '' unless renderer
+
+        case input
+        when Drop::Base
+          renderer.render_drop(input)
+        when Array
+          input.map { |i| render_element(i) }.join("\n")
+        when Hash
+          render_hash_data(input, renderer)
+        when String
+          input
+        else
+          drop = Drop::DropFactory.create(input)
+          drop.is_a?(Drop::Base) ? renderer.render_drop(drop) : drop.to_s
+        end
       end
 
-      # Escape HTML entities
       def escape_html(input)
-        input.to_s
-             .gsub(/&/, '&')
-             .gsub(/</, '&lt;')
-             .gsub(/>/, '&gt;')
-             .gsub(/"/, '&quot;')
-             .gsub(/'/, '&#39;')
+        Escape.escape_html(input)
       end
 
       # Escape HTML attribute values
       def escape_attr(input)
-        input.to_s
-             .gsub(/&/, '&amp;')
-             .gsub(/"/, '&quot;')
-             .gsub(/</, '&lt;')
-             .gsub(/>/, '&gt;')
+        Escape.escape_attr(input)
+      end
+
+      # JSON-encode with </script protection for inline JS
+      def safe_json(input)
+        Escape.safe_json(input)
+      end
+
+      private
+
+      def render_hash_data(data, renderer)
+        drop_type = data['drop_type']
+        return data.to_s unless drop_type
+
+        template = renderer.find_template(drop_type)
+        return data.to_s unless template
+
+        template.render(data, registers: { renderer: renderer }).strip
       end
     end
   end
 end
 
-# Register filters with Liquid (using the non-deprecated API)
+# Register filters with Liquid
 Liquid::Environment.default.register_filter(Coradoc::Html::TemplateFilters)

data/lib/coradoc/html/template_locator.rb

@@ -23,6 +23,9 @@ module Coradoc
       # Default template subdirectory within each template root
       CORE_MODEL_DIR = 'core_model'
 
+      # Canonical default template directory within the gem
+      DEFAULT_TEMPLATE_DIR = Pathname.new(File.join(File.dirname(__FILE__), 'templates', CORE_MODEL_DIR)).freeze
+
       attr_reader :user_dirs, :default_dir
 
       # Initialize the locator
@@ -42,12 +45,14 @@ module Coradoc
       def find(type_name)
         return @cache[type_name] if @cache.key?(type_name)
 
-        # First check user directories
+        # First check user directories (core_model/ subdir, then root)
         @user_dirs.each do |dir|
-          template_path = dir / CORE_MODEL_DIR / "#{type_name}.liquid"
-          if template_path.exist?
-            @cache[type_name] = template_path
-            return template_path
+          %W[#{dir}/#{CORE_MODEL_DIR}/#{type_name}.liquid #{dir}/#{type_name}.liquid].each do |template_path|
+            path = Pathname.new(template_path)
+            if path.exist?
+              @cache[type_name] = path
+              return path
+            end
           end
         end
 
@@ -78,13 +83,14 @@ module Coradoc
       def available_templates
         types = Set.new
 
-        # Collect from user directories
+        # Collect from user directories (root and core_model/ subdir)
         @user_dirs.each do |dir|
-          core_model_path = dir / CORE_MODEL_DIR
-          next unless core_model_path.exist? && core_model_path.directory?
+          [dir, dir / CORE_MODEL_DIR].each do |scan_dir|
+            next unless scan_dir.exist? && scan_dir.directory?
 
-          core_model_path.glob('*.liquid') do |f|
-            types.add(f.basename('.liquid').to_s)
+            scan_dir.glob('*.liquid') do |f|
+              types.add(f.basename('.liquid').to_s)
+            end
           end
         end
 
@@ -102,7 +108,7 @@ module Coradoc
       #
       # @return [Pathname] Path to default templates
       def default_template_dir
-        Pathname.new(File.join(File.dirname(__FILE__), 'templates', CORE_MODEL_DIR))
+        DEFAULT_TEMPLATE_DIR
       end
 
       # Clear the template cache (useful when template directories change)

data/lib/coradoc/html/theme.rb

@@ -2,12 +2,6 @@
 
 module Coradoc
   module Html
-    module Theme
-      # Autoload Theme components
-      autoload :Base, 'coradoc/html/theme/base'
-      autoload :Registry, 'coradoc/html/theme/registry'
-      autoload :ClassicRenderer, 'coradoc/html/theme/classic_renderer'
-      autoload :ModernRenderer, 'coradoc/html/theme/modern_renderer'
-    end
+    module Theme; end
   end
 end

data/lib/coradoc/html/title_text.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    # Resolves CoreModel title attributes to plain-text strings.
+    #
+    # CoreModel titles can be String, CoreModel::Base (with .text),
+    # Array of mixed types, or nil. This utility provides a single
+    # resolution path used by TocBuilder, TocSerializer, Renderer,
+    # LayoutRenderer, and Drop classes.
+    module TitleText
+      TEXT_TYPES = [CoreModel::TextContent, CoreModel::Term].freeze
+
+      module_function
+
+      def resolve(title)
+        case title
+        when nil then nil
+        when String then title
+        when CoreModel::Base then resolve_model(title)
+        when Array then title.map { |t| resolve_element(t) }.join
+        else title.to_s
+        end
+      end
+
+      def escape(title)
+        resolved = resolve(title)
+        resolved ? Escape.escape_html(resolved) : nil
+      end
+
+      def resolve_model(model)
+        if text_type?(model) && model.text
+          model.text
+        elsif content_type?(model) && model.content
+          model.content.to_s
+        else
+          model.to_s
+        end
+      end
+
+      def resolve_element(element)
+        case element
+        when CoreModel::Base then resolve_model(element)
+        else element.to_s
+        end
+      end
+
+      def text_type?(model)
+        TEXT_TYPES.any? { |t| model.is_a?(t) }
+      end
+
+      def content_type?(model)
+        model.is_a?(CoreModel::InlineElement) || model.is_a?(CoreModel::StructuralElement)
+      end
+    end
+  end
+end

data/lib/coradoc/html/toc_builder.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    # Builds a CoreModel::Toc from a document's StructuralElement tree.
+    #
+    # Walks the section hierarchy, assigns section numbers, and returns
+    # a Toc model with nested TocEntry children. Section numbers are
+    # derived from tree position — single source of truth for both
+    # TOC rendering and heading numbering.
+    class TocBuilder
+      def initialize(max_level: 6, numbered: false, section_number_levels: 3)
+        @max_level = max_level
+        @numbered = numbered
+        @section_number_levels = section_number_levels
+      end
+
+      # Build a TocBuilder from renderer-style options hash.
+      #
+      # @param options [Hash] options with :section_number_levels, :toc_levels, :section_numbers
+      # @return [TocBuilder]
+      def self.from_options(options)
+        section_number_levels = options[:section_number_levels] || 3
+        toc_levels = options[:toc_levels] || 2
+        max_level = [toc_levels, section_number_levels].min
+        new(max_level: max_level, numbered: options[:section_numbers] == true, section_number_levels: section_number_levels)
+      end
+
+      # Build a Toc model from a document.
+      #
+      # @param document [CoreModel::StructuralElement] the root document
+      # @return [CoreModel::Toc] the built TOC with entries and section numbers
+      def build(document)
+        entries = []
+        counters = [0]
+        collect_entries(document.children, entries, 1, counters) if document.children
+
+        CoreModel::Toc.new(
+          entries: entries,
+          min_level: 1,
+          max_level: @max_level,
+          numbered: @numbered
+        )
+      end
+
+      # Compute a mapping of section_id => section_number_string.
+      # Always computes numbers regardless of the +numbered+ flag,
+      # since this is used for heading annotation in the body.
+      #
+      # @param document [CoreModel::StructuralElement] the root document
+      # @return [Hash{String => String}] mapping of section ID to number (e.g., "2.1")
+      def section_number_map(document)
+        map = {}
+        entries = []
+        counters = [0]
+        collect_entries(document.children, entries, 1, counters, always_number: true) if document.children
+        flatten_numbers(entries, map)
+        map
+      end
+
+      private
+
+      def collect_entries(items, entries, level, counters, always_number: false)
+        return unless items && level <= @max_level
+
+        items.each do |item|
+          next unless item.is_a?(CoreModel::StructuralElement)
+          next unless item.section? || item.header?
+
+          counters[level] = (counters[level] || 0) + 1
+          ((level + 1)..@section_number_levels).each { |i| counters[i] = 0 }
+
+          use_number = always_number || @numbered
+          number = use_number && level <= @section_number_levels ? counters[1..level].join('.') : nil
+
+          children = []
+          collect_entries(item.children, children, level + 1, counters, always_number: always_number) if item.children
+
+          entries << CoreModel::TocEntry.new(
+            id: entry_id(item),
+            title: entry_title(item),
+            level: level,
+            number: number,
+            children: children
+          )
+        end
+      end
+
+      def flatten_numbers(entries, map)
+        entries.each do |entry|
+          map[entry.id] = entry.number if entry.id && entry.number
+          flatten_numbers(entry.children, map) if entry.children
+        end
+      end
+
+      def entry_title(section)
+        TitleText.resolve(section.title)
+      end
+
+      def entry_id(section)
+        section.id
+      end
+    end
+  end
+end

data/lib/coradoc/html/toc_serializer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Html
+    # Serializes a document's TOC structure to JSON for inline embedding.
+    #
+    # Used by the SPA layout to provide client-side navigation data.
+    class TocSerializer
+      def build_json(document, options)
+        return { entries: [], numbered: false } unless document.is_a?(CoreModel::StructuralElement)
+
+        numbered = options[:section_numbers] == true
+        builder = TocBuilder.from_options(options)
+        toc = builder.build(document)
+        { entries: serialize_entries(toc.entries), numbered: numbered }
+      end
+
+      private
+
+      def serialize_entries(entries)
+        entries.map do |entry|
+          {
+            id: entry.id,
+            title: TitleText.resolve(entry.title),
+            number: entry.number,
+            level: entry.level,
+            children: entry.children.any? ? serialize_entries(entry.children) : []
+          }
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/transform/from_core_model.rb

@@ -1,28 +1,29 @@
 # frozen_string_literal: true
 
+require 'coradoc/core_model'
+
 module Coradoc
   module Html
     module Transform
-      # Transforms CoreModel models to HTML output
+      # Transforms CoreModel to HTML output
       #
-      # This transformer converts CoreModel to structures suitable for
-      # HTML rendering. Note: The HTML converters already support CoreModel
-      # directly, so this transformer primarily passes through the CoreModel.
+      # This transformer converts CoreModel to HTML strings by delegating
+      # to the existing theme/renderer pipeline.
       class FromCoreModel
         class << self
-          # Transform a CoreModel to HTML-ready structure
+          # Transform a CoreModel to HTML string
           #
-          # @param model [Coradoc::CoreModel::Base] CoreModel to transform
-          # @return [Object] HTML-ready structure
-          def transform(model)
+          # @param model [Coradoc::CoreModel::Base, Array] CoreModel to transform
+          # @param options [Hash] Renderer options (e.g., theme)
+          # @return [String] HTML output
+          def transform(model, options = {})
             case model
             when Coradoc::CoreModel::Base
-              # HTML converters already support CoreModel directly
-              model
+              Html.serialize(model, options)
             when Array
-              model.map { |item| transform(item) }
+              model.map { |item| transform(item, options) }.join("\n")
             else
-              model
+              model.to_s
             end
           end
         end

data/lib/coradoc/html/transform/to_core_model.rb

@@ -1,31 +1,29 @@
 # frozen_string_literal: true
 
+require 'nokogiri'
 require 'coradoc/core_model'
 
 module Coradoc
   module Html
     module Transform
-      # Transforms HTML input models to CoreModel equivalents
+      # Transforms Nokogiri HTML nodes to CoreModel
       #
-      # HTML input converters now produce CoreModel directly, so this transformer
-      # is largely a pass-through that ensures the model is CoreModel.
+      # Nokogiri serves as the HTML model layer. This transformer converts
+      # Nokogiri::XML::Document or Nokogiri::XML::Node objects into CoreModel
+      # by delegating to the existing input converter pipeline.
       class ToCoreModel
         class << self
-          # Transform an HTML input model to CoreModel
+          # Transform an HTML model (Nokogiri node) to CoreModel
           #
-          # @param model [Object] HTML input model to transform
+          # @param model [Nokogiri::XML::Document, Nokogiri::XML::Node, Coradoc::CoreModel::Base]
+          #   HTML input model to transform
           # @return [Coradoc::CoreModel::Base] CoreModel equivalent
           def transform(model)
-            # HTML input now produces CoreModel directly
-            transform_direct(model)
-          end
-
-          private
-
-          def transform_direct(model)
             case model
             when Coradoc::CoreModel::Base
               model
+            when Nokogiri::XML::Document, Nokogiri::XML::Node
+              ::Coradoc::Input::Html::HtmlConverter.to_core_model(model)
             when Array
               model.map { |item| transform(item) }
             else

data/lib/coradoc/html/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module Html
-    VERSION = '1.1.7'
+    VERSION = '1.1.13'
   end
 end