coradoc-html 1.1.14 → 1.1.15

data/lib/coradoc/html/config.rb

@@ -1,116 +1,73 @@
 # frozen_string_literal: true
 
-require 'nokogiri'
-
 module Coradoc
   module Html
     module Config
       DEFAULT_LANG = 'en'
       DEFAULT_TITLE = 'Untitled'
 
-      # Default HTML output options
       DEFAULT_OPTIONS = {
-        # Theme system options
         theme: :classic,
         modern: {
-          # Appearance
           color_scheme: :glass,
           primary_color: '#6366f1',
           accent_color: '#8b5cf6',
-
-          # Layout
           max_width: '1200px',
           content_width: '65ch',
           sidebar_width: '280px',
-
-          # Features
           theme_toggle: true,
           reading_progress: true,
           back_to_top: true,
           toc_sticky: true,
           copy_code_buttons: true,
-
-          # Animation
           enable_animations: true,
           animation_duration: '300ms',
-
-          # Performance
           lazy_load_images: true
         }.freeze,
-
-        # HTML version
         html_version: :html5,
-
-        # Formatting options
         pretty_print: false,
         indent: '  ',
         line_wrap: 0,
-
-        # Content options
         escape_content: true,
         preserve_whitespace: false,
         convert_line_breaks: true,
         preserve_comments: false,
-
-        # Element options
         use_semantic_elements: true,
         add_css_classes: true,
         add_data_attributes: false,
-
-        # Link options
         external_link_target: nil,
         link_rel: nil,
-
-        # Image options
         image_loading: nil,
         image_decoding: nil,
-
-        # Code block options
         syntax_highlighter: nil,
         syntax_highlighter_opts: {},
-
-        # Table options
         table_border: false,
         table_stripes: false,
-
-        # Attribute options
         preserve_custom_attributes: true,
         attribute_prefix: 'data-',
-
-        # CSS & Styling options
         stylesheet: 'coradoc.css',
         stylesdir: './css',
         linkcss: false,
         copycss: true,
         css_theme: 'professional',
         custom_css: nil,
-
-        # JavaScript options
         javascript: 'coradoc.js',
         jsdir: './js',
         linkjs: false,
         theme_toggle: true,
         toc_interactive: nil,
-
-        # Document metadata options
         author: nil,
         description: nil,
         keywords: nil,
         lang: 'en',
         embedded: false,
         meta_tags: {},
-
-        # Table of contents options
         toc: false,
         toclevels: 2,
         toc_title: 'Table of Contents',
         toc_placement: :auto,
-
-        # Section numbering options
         sectnums: false,
         sectnumlevels: 3,
-
-        # Syntax highlighting options
         source_highlighter: nil,
         highlightjs_theme: 'github',
         pygments_style: 'default',
@@ -118,17 +75,14 @@ module Coradoc
       }.freeze
 
       class << self
-        # Get default options
         def default_options
           DEFAULT_OPTIONS.dup
         end
 
-        # Merge user options with defaults
         def merge_options(user_options = {})
           default_options.merge(user_options)
         end
 
-        # Validate options
         def validate_options(options)
           valid_keys = DEFAULT_OPTIONS.keys
           invalid_keys = options.keys - valid_keys
@@ -138,19 +92,16 @@ module Coradoc
           options
         end
 
-        # Get CSS class for element type
         def css_class_for(element_type, role = nil)
           classes = [element_type.to_s.tr('_', '-')]
           classes << role if role
           classes.join(' ')
         end
 
-        # Get data attribute name
         def data_attribute_name(name, prefix: 'data-')
           "#{prefix}#{name.to_s.tr('_', '-')}"
         end
 
-        # Build element configuration
         def element_config(element_type, options = {})
           {
             tag: html_tag_for(element_type),
@@ -159,333 +110,42 @@ module Coradoc
           }
         end
 
-        # Map element type to HTML tag
         def html_tag_for(element_type)
-          TAG_MAPPING[element_type] || 'div'
-        end
-
-        # Get stylesheet path
-        def stylesheet_path(options = {})
-          # When linking, use css_theme-based filename, not the stylesheet option
-          css_theme = options[:css_theme] || DEFAULT_OPTIONS[:css_theme]
-          stylesheet = "#{css_theme}.css"
-          stylesdir = options[:stylesdir] || DEFAULT_OPTIONS[:stylesdir]
-
-          if stylesdir && stylesdir != '.'
-            File.join(stylesdir, stylesheet)
-          else
-            stylesheet
-          end
-        end
-
-        # Get embedded stylesheet content
-        def embedded_stylesheet(options = {})
-          css_theme = options[:css_theme] || DEFAULT_OPTIONS[:css_theme]
-          stylesheet_name = "#{css_theme}.css"
-
-          # Try themes directory first
-          themes_path = File.join(__dir__, 'assets', 'themes', stylesheet_name)
-          asset_path = if File.exist?(themes_path)
-                         themes_path
-                       else
-                         # Fall back to assets directory for backward compatibility
-                         File.join(__dir__, 'assets', stylesheet_name)
-                       end
-
-          css_content = if File.exist?(asset_path)
-                          File.read(asset_path)
-                        else
-                          # Fallback to default coradoc.css
-                          default_path = File.join(__dir__, 'assets', 'coradoc.css')
-                          File.exist?(default_path) ? File.read(default_path) : ''
-                        end
-
-          # Resolve @import statements for embedded CSS
-          # @import doesn't work in inline <style> tags
-          resolve_css_imports(css_content, File.dirname(asset_path))
-        end
-
-        # Resolve @import statements in CSS content
-        # @param css_content [String] CSS content with potential @import statements
-        # @param base_dir [String] Base directory for resolving relative imports
-        # @return [String] CSS content with imports resolved
-        def resolve_css_imports(css_content, base_dir)
-          # Match @import url('...') or @import url("...") or @import '...' or @import "..."
-          css_content.gsub(/@import\s+(?:url\()?['"]([^'"]+)['"]\)?;?/) do
-            import_path = ::Regexp.last_match(1)
-            full_path = File.join(base_dir, import_path)
-
-            if File.exist?(full_path)
-              # Read the imported file and recursively resolve its imports
-              imported_content = File.read(full_path)
-              resolve_css_imports(imported_content, File.dirname(full_path))
-            else
-              # Keep the original import if file not found
-              ::Regexp.last_match(0)
-            end
-          end
-        end
-
-        # Build CSS link tag
-        def css_link_tag(options = {})
-          href = stylesheet_path(options)
-          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
-        def css_style_tag(options = {})
-          css_content = embedded_stylesheet(options)
-          custom_css = options[:custom_css]
-
-          content = css_content
-          content += "\n\n#{custom_css}" if custom_css && !custom_css.empty?
-
-          build_text_element('style', content)
-        end
-
-        # Build custom CSS style tag
-        def custom_css_tag(custom_css)
-          return '' unless custom_css && !custom_css.empty?
-
-          build_text_element('style', custom_css)
-        end
-
-        # Determine whether to embed or link CSS
-        def embed_css?(options = {})
-          # Embed if linkcss is false or embedded mode is true
-          !options.fetch(:linkcss, DEFAULT_OPTIONS[:linkcss]) ||
-            options.fetch(:embedded, DEFAULT_OPTIONS[:embedded])
-        end
-
-        # Build complete CSS tags (link or embedded, plus custom)
-        def css_tags(options = {})
-          tags = []
-
-          if embed_css?(options)
-            # Embedded mode: include full stylesheet in style tag
-            tags << css_style_tag(options)
-          else
-            # Linked mode: link to external stylesheet
-            tags << css_link_tag(options)
-            # Add custom CSS separately if provided
-            tags << custom_css_tag(options[:custom_css]) if options[:custom_css]
-          end
-
-          tags.join("\n")
+          TagMapping.tag_for(element_type)
         end
 
-        # Determine whether to embed or link JavaScript
-        def embed_js?(options = {})
-          # Embed if linkjs is false, embedded mode is true, or linkcss is false (to match CSS behavior)
-          !options.fetch(:linkjs, DEFAULT_OPTIONS[:linkjs]) ||
-            options.fetch(:embedded, DEFAULT_OPTIONS[:embedded]) ||
-            !options.fetch(:linkcss, DEFAULT_OPTIONS[:linkcss])
-        end
-
-        # Get JavaScript file path
-        def javascript_path(options = {})
-          javascript = options[:javascript] || DEFAULT_OPTIONS[:javascript]
-          jsdir = options[:jsdir] || DEFAULT_OPTIONS[:jsdir]
-
-          if jsdir && jsdir != '.'
-            File.join(jsdir, javascript)
-          else
-            javascript
-          end
-        end
-
-        # Get embedded JavaScript content
-        def embedded_javascript(options = {})
-          javascript_name = options[:javascript] || DEFAULT_OPTIONS[:javascript]
-          asset_path = File.join(__dir__, 'assets', 'js', javascript_name)
-
-          if File.exist?(asset_path)
-            File.read(asset_path)
-          else
-            ''
-          end
-        end
-
-        # Build JavaScript link tag
-        def js_link_tag(options = {})
-          src = javascript_path(options)
-          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
-        def js_script_tag(options = {})
-          js_content = embedded_javascript(options)
-          return '' if js_content.empty?
-
-          build_text_element('script', js_content)
-        end
-
-        # Build complete JavaScript tags (link or embedded)
-        def js_tags(options = {})
-          return '' if options[:javascript] == false
-
-          tags = []
+        def code_block_attributes(language, options = {})
+          attrs = {}
+          attrs[:class] = "language-#{language}" if language && !language.empty?
 
-          tags << if embed_js?(options)
-                    # Embedded mode: include full JavaScript in script tag
-                    js_script_tag(options)
-                  else
-                    # Linked mode: link to external JavaScript file
-                    js_link_tag(options)
-                  end
+          attrs[:class] = [attrs[:class], 'line-numbers'].compact.join(' ') if options[:linenums] || options[:line_numbers]
 
-          tags.join("\n")
+          attrs
         end
 
-        # Check if theme toggle should be enabled
         def theme_toggle?(options = {})
           options.fetch(:theme_toggle, DEFAULT_OPTIONS[:theme_toggle])
         end
 
-        # Check if interactive TOC should be enabled
         def toc_interactive?(options = {})
-          # Default to true if TOC is enabled and toc_interactive is not explicitly set to false
           toc_enabled = options.fetch(:toc, DEFAULT_OPTIONS[:toc])
           toc_interactive = options[:toc_interactive]
-
-          # If toc_interactive is nil, default to true when TOC is enabled
-          if toc_interactive.nil?
-            toc_enabled
-          else
-            toc_interactive
-          end
-        end
-
-        # Build syntax highlighter tags (CSS and JS)
-        # @param options [Hash] Configuration options
-        # @return [String] HTML tags for syntax highlighting
-        def syntax_highlighter_tags(options = {})
-          highlighter = options[:source_highlighter]
-          return '' unless highlighter
-
-          case highlighter.to_sym
-          when :highlightjs, :highlight_js, :'highlight.js'
-            highlightjs_tags(options)
-          when :pygments
-            # Pygments requires server-side processing, not implemented for client-side HTML
-            ''
-          when :rouge
-            # Rouge requires server-side processing, not implemented for client-side HTML
-            ''
-          else
-            ''
-          end
-        end
-
-        # Build Highlight.js tags
-        # @param options [Hash] Configuration options
-        # @return [String] HTML tags for Highlight.js
-        def highlightjs_tags(options = {})
-          theme = options[:highlightjs_theme] || DEFAULT_OPTIONS[:highlightjs_theme]
-          doc = Nokogiri::HTML::Document.new
-
-          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"
-
-          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")
+          toc_interactive.nil? ? toc_enabled : toc_interactive
         end
+      end
 
-        # Get data attributes for code block
-        # @param language [String] Programming language
-        # @param options [Hash] Code block options
-        # @return [Hash] Data attributes
-        def code_block_attributes(language, options = {})
-          attrs = {}
-
-          attrs[:class] = "language-#{language}" if language && !language.empty?
-
-          if options[:linenums] || options[:line_numbers]
-            attrs[:class] =
-              [attrs[:class], 'line-numbers'].compact.join(' ')
-          end
-
-          attrs
-        end
-
-        # Mapping of Coradoc elements to HTML tags
-        TAG_MAPPING = {
-          # Sections
-          section: 'section',
-          header: 'header',
-
-          # Blocks
-          paragraph: 'p',
-          example: 'div',
-          sidebar: 'aside',
-          quote: 'blockquote',
-          verse: 'div',
-          listing: 'pre',
-          literal: 'pre',
-          source: 'pre',
-          open: 'div',
-
-          # Lists
-          ordered_list: 'ol',
-          unordered_list: 'ul',
-          list_item: 'li',
-          description_list: 'dl',
-          description_term: 'dt',
-          description_detail: 'dd',
-
-          # Tables
-          table: 'table',
-          table_row: 'tr',
-          table_cell: 'td',
-          table_header: 'th',
-
-          # Inline
-          bold: 'strong',
-          italic: 'em',
-          monospace: 'code',
-          highlight: 'mark',
-          superscript: 'sup',
-          subscript: 'sub',
-          underline: 'u',
-          strikethrough: 'del',
-          small_caps: 'span',
-
-          # Links
-          anchor: 'a',
-          cross_reference: 'a',
-
-          # Media
-          image: 'img',
-          video: 'video',
-          audio: 'audio',
-
-          # Other
-          break: 'hr',
-          line_break: 'br',
-          admonition: 'div'
-        }.freeze
+      ASSET_METHODS = %i[
+        stylesheet_path embedded_stylesheet resolve_css_imports
+        css_link_tag css_style_tag custom_css_tag embed_css? css_tags
+        javascript_path embedded_javascript
+        js_link_tag js_script_tag embed_js? js_tags
+        syntax_highlighter_tags highlightjs_tags
+      ].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
+      ASSET_METHODS.each do |method|
+        define_method(method) { |*args, **kwargs, &blk| AssetResolver.public_send(method, *args, **kwargs, &blk) }
       end
+      module_function(*ASSET_METHODS)
     end
   end
 end

data/lib/coradoc/html/converter_base.rb

@@ -28,14 +28,53 @@ module Coradoc
       # Provides shared `merge` and `defaults` patterns.
       # Subclasses define `initialize`, `to_h`, and `validate!`.
       class ConfigurationBase
-        def self.defaults
-          new
+        class << self
+          # Declare a configuration attribute with an optional default.
+          # Replaces manual attr_accessor + initialize + to_h boilerplate.
+          def attribute(name, default: nil)
+            attr_accessor name
+
+            configuration_attributes[name] = default
+          end
+
+          # Registry of declared attributes and their defaults
+          def configuration_attributes
+            @configuration_attributes ||= {}
+          end
+
+          def defaults
+            new
+          end
+        end
+
+        def initialize(**options)
+          self.class.configuration_attributes.each do |name, default|
+            value = options.fetch(name) { default.respond_to?(:call) ? default.call : default }
+            public_send(:"#{name}=", value)
+          end
+        end
+
+        def to_h
+          self.class.configuration_attributes.each_with_object({}) do |(name, _), hash|
+            hash[name] = public_send(name)
+          end
         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
+
+        protected
+
+        def range_check(name, min, max, label: nil)
+          value = public_send(name)
+          return if value.is_a?(Integer) && value.between?(min, max)
+
+          display = label || name.to_s.tr('_', ' ').gsub(/\b\w/, &:upcase)
+          raise ConverterBase::ValidationError,
+                "#{display} must be an integer between #{min} and #{max}"
+        end
       end
 
       attr_reader :document, :config

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

@@ -4,23 +4,12 @@ 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'
+          TagMapping.tag_for(resolved_semantic_type)
         end
 
         def language
@@ -28,7 +17,7 @@ module Coradoc
         end
 
         def css_class
-          cls = SEMANTIC_CLASS_MAP[resolved_semantic_type]
+          cls = TagMapping.css_class_for(resolved_semantic_type)
           cls ? "block-#{semantic_type} #{cls}" : "block-#{semantic_type}"
         end
 

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

@@ -4,31 +4,12 @@ module Coradoc
   module Html
     module Drop
       class InlineElementDrop < Base
-        FORMAT_TAG_MAP = {
-          'bold' => 'strong',
-          'italic' => 'em',
-          'monospace' => 'code',
-          'superscript' => 'sup',
-          'subscript' => 'sub',
-          'underline' => 'u',
-          'strikethrough' => 'del',
-          'highlight' => 'mark',
-          'quotation' => 'q',
-          'small' => 'small',
-          'stem' => 'code'
-        }.freeze
-
         def format_type
           @model.resolve_format_type
         end
 
         def html_tag
-          case format_type
-          when 'link', 'xref' then 'a'
-          when 'footnote' then 'sup'
-          when 'span', 'term' then 'span'
-          else FORMAT_TAG_MAP[format_type]
-          end
+          TagMapping.tag_for(format_type)
         end
 
         def href

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

@@ -5,11 +5,7 @@ module Coradoc
     module Drop
       class ListBlockDrop < Base
         def html_tag
-          case @model.marker_type
-          when 'ordered' then 'ol'
-          when 'definition' then 'dl'
-          else 'ul'
-          end
+          TagMapping.tag_for(@model.marker_type)
         end
 
         def items

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

@@ -9,7 +9,7 @@ module Coradoc
         end
 
         def html_tag
-          header? ? 'th' : 'td'
+          TagMapping.tag_for(header? ? :table_header : :table_cell)
         end
 
         def colspan