coradoc-html 1.1.7 → 1.1.13

data/lib/coradoc/html/element_mapping.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Html
-    # Element mapping between CoreModel and HTML elements
-    #
-    # This module provides bidirectional mapping between CoreModel types
-    # and HTML elements for conversion purposes.
-    module ElementMapping
-      class << self
-        # Map CoreModel class to HTML element
-        def model_to_html_element(model_class)
-          model_name = model_class.name.split('::').last.downcase.to_sym
-          MODEL_TO_HTML[model_name] || default_element_for(model_class)
-        end
-
-        # Map HTML element to CoreModel class
-        def html_element_to_model(tag_name, context = {})
-          tag = tag_name.to_s.downcase.to_sym
-          HTML_TO_MODEL[tag] || default_model_for(tag, context)
-        end
-
-        # Get default element for a model class
-        def default_element_for(model_class)
-          if model_class.ancestors.any? { |a| a.name&.include?('InlineElement') }
-            { tag: 'span', semantic: false }
-          else
-            { tag: 'div', semantic: false }
-          end
-        end
-
-        # Get default model for an HTML element
-        def default_model_for(tag, _context)
-          # Return CoreModel types
-          case tag
-          when :p, :div, :section, :article
-            'Coradoc::CoreModel::Block'
-          when :strong, :b, :em, :i, :code
-            'Coradoc::CoreModel::InlineElement'
-          else
-            'Coradoc::CoreModel::InlineElement'
-          end
-        end
-
-        # Mapping from CoreModel types to HTML elements
-        MODEL_TO_HTML = {
-          # Document structure
-          document: { tag: 'article', semantic: true },
-          section: { tag: 'section', semantic: true },
-          header: { tag: 'header', semantic: true },
-          title: { tag: 'h1', semantic: true },
-          structuralelement: { tag: 'section', semantic: true },
-
-          # Block elements
-          paragraph: { tag: 'p', semantic: true },
-          block: { tag: 'div', semantic: true },
-          example: { tag: 'div', class: 'example', semantic: false },
-          annotationblock: { tag: 'aside', semantic: true },
-          quote: { tag: 'blockquote', semantic: true },
-          verse: { tag: 'div', class: 'verse', semantic: false },
-          listing: { tag: 'pre', semantic: true },
-          literal: { tag: 'pre', semantic: true },
-          source: { tag: 'pre', semantic: true },
-          open: { tag: 'div', semantic: false },
-          pass: { tag: 'div', class: 'pass', semantic: false },
-
-          # Inline elements
-          inlineelement: { tag: 'span', semantic: false },
-          bold: { tag: 'strong', semantic: true },
-          italic: { tag: 'em', semantic: true },
-          monospace: { tag: 'code', semantic: true },
-          highlight: { tag: 'mark', semantic: true },
-          superscript: { tag: 'sup', semantic: true },
-          subscript: { tag: 'sub', semantic: true },
-          underline: { tag: 'u', semantic: false },
-          strikethrough: { tag: 'del', semantic: true },
-          smallcaps: { tag: 'span', class: 'small-caps', semantic: false },
-          link: { tag: 'a', semantic: true },
-          anchor: { tag: 'a', semantic: true },
-          xref: { tag: 'a', class: 'xref', semantic: true },
-          quotation: { tag: 'q', semantic: true },
-
-          # Lists
-          listblock: { tag: 'ul', semantic: true },
-          listitem: { tag: 'li', semantic: true },
-          orderedlist: { tag: 'ol', semantic: true },
-          unorderedlist: { tag: 'ul', semantic: true },
-
-          # Tables
-          table: { tag: 'table', semantic: true },
-          tablerow: { tag: 'tr', semantic: true },
-          tablecell: { tag: 'td', semantic: true },
-
-          # Media
-          image: { tag: 'img', semantic: true, self_closing: true },
-          video: { tag: 'video', semantic: true },
-          audio: { tag: 'audio', semantic: true },
-
-          # Other
-          break: { tag: 'hr', semantic: true, self_closing: true },
-          linebreak: { tag: 'br', semantic: true, self_closing: true },
-
-          # Text
-          textelement: { tag: 'text', semantic: false }
-        }.freeze
-
-        # Mapping from HTML elements to CoreModel types
-        HTML_TO_MODEL = {
-          # Block elements
-          p: 'Coradoc::CoreModel::Block',
-          div: 'Coradoc::CoreModel::Block',
-          section: 'Coradoc::CoreModel::StructuralElement',
-          article: 'Coradoc::CoreModel::StructuralElement',
-          header: 'Coradoc::CoreModel::StructuralElement',
-          aside: 'Coradoc::CoreModel::AnnotationBlock',
-          blockquote: 'Coradoc::CoreModel::Block',
-          pre: 'Coradoc::CoreModel::Block',
-
-          # Inline elements
-          strong: 'Coradoc::CoreModel::InlineElement',
-          b: 'Coradoc::CoreModel::InlineElement',
-          em: 'Coradoc::CoreModel::InlineElement',
-          i: 'Coradoc::CoreModel::InlineElement',
-          code: 'Coradoc::CoreModel::InlineElement',
-          mark: 'Coradoc::CoreModel::InlineElement',
-          sup: 'Coradoc::CoreModel::InlineElement',
-          sub: 'Coradoc::CoreModel::InlineElement',
-          u: 'Coradoc::CoreModel::InlineElement',
-          del: 'Coradoc::CoreModel::InlineElement',
-          s: 'Coradoc::CoreModel::InlineElement',
-          strike: 'Coradoc::CoreModel::InlineElement',
-
-          # Links
-          a: 'Coradoc::CoreModel::InlineElement',
-
-          # Lists
-          ul: 'Coradoc::CoreModel::ListBlock',
-          ol: 'Coradoc::CoreModel::ListBlock',
-          li: 'Coradoc::CoreModel::ListItem',
-          dl: 'Coradoc::CoreModel::ListBlock',
-          dt: 'Coradoc::CoreModel::ListItem',
-          dd: 'Coradoc::CoreModel::ListItem',
-
-          # Tables
-          table: 'Coradoc::CoreModel::Table',
-          tr: 'Coradoc::CoreModel::TableRow',
-          td: 'Coradoc::CoreModel::TableCell',
-          th: 'Coradoc::CoreModel::TableCell',
-
-          # Media
-          img: 'Coradoc::CoreModel::Image',
-          video: 'Coradoc::CoreModel::Block',
-          audio: 'Coradoc::CoreModel::Block',
-
-          # Other
-          hr: 'Coradoc::CoreModel::Block',
-          br: 'Coradoc::CoreModel::InlineElement',
-
-          # Headings
-          h1: 'Coradoc::CoreModel::StructuralElement',
-          h2: 'Coradoc::CoreModel::StructuralElement',
-          h3: 'Coradoc::CoreModel::StructuralElement',
-          h4: 'Coradoc::CoreModel::StructuralElement',
-          h5: 'Coradoc::CoreModel::StructuralElement',
-          h6: 'Coradoc::CoreModel::StructuralElement'
-        }.freeze
-
-        # Check if HTML element is block-level
-        def block_element?(tag)
-          BLOCK_ELEMENTS.include?(tag.to_sym)
-        end
-
-        # Check if HTML element is inline-level
-        def inline_element?(tag)
-          INLINE_ELEMENTS.include?(tag.to_sym)
-        end
-
-        # Check if HTML element is self-closing
-        def self_closing?(tag)
-          SELF_CLOSING_ELEMENTS.include?(tag.to_sym)
-        end
-
-        # Block-level HTML elements
-        BLOCK_ELEMENTS = %i[
-          div p section article aside header footer main nav
-          blockquote pre ul ol li dl dt dd
-          table tr td th thead tbody tfoot
-          h1 h2 h3 h4 h5 h6
-          hr
-          figure figcaption
-        ].freeze
-
-        # Inline-level HTML elements
-        INLINE_ELEMENTS = %i[
-          span strong em b i u s del ins mark small
-          code kbd samp var
-          a abbr cite dfn q
-          sub sup
-          time
-          br wbr
-        ].freeze
-
-        # Self-closing HTML elements
-        SELF_CLOSING_ELEMENTS = %i[
-          area base br col embed hr img input link meta param source track wbr
-        ].freeze
-      end
-    end
-  end
-end

data/lib/coradoc/html/entity.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Html
-    # HTML entity handling
-    module Entity
-      # Named HTML entities
-      NAMED_ENTITIES = {
-        'nbsp' => "\u00A0",
-        'lt' => '<',
-        'gt' => '>',
-        'amp' => '&',
-        'quot' => '"',
-        'apos' => "'",
-        'cent' => "\u00A2",
-        'pound' => "\u00A3",
-        'yen' => "\u00A5",
-        'euro' => "\u20AC",
-        'copy' => "\u00A9",
-        'reg' => "\u00AE",
-        'trade' => "\u2122",
-        'mdash' => "\u2014",
-        'ndash' => "\u2013",
-        'hellip' => "\u2026",
-        'laquo' => "\u00AB",
-        'raquo' => "\u00BB",
-        'ldquo' => "\u201C",
-        'rdquo' => "\u201D",
-        'lsquo' => "\u2018",
-        'rsquo' => "\u2019"
-      }.freeze
-
-      class << self
-        # Encode text to HTML entities
-        def encode(text, options = {})
-          return '' if text.nil?
-          return text unless text.is_a?(String)
-
-          encoded = text.dup
-
-          # Basic HTML entities
-          encoded = encoded
-                    .gsub('&', '&amp;')
-                    .gsub('<', '&lt;')
-                    .gsub('>', '&gt;')
-                    .gsub('"', '&quot;')
-
-          # Optionally encode additional characters
-          encoded = encoded.gsub("'", '&#39;') if options[:encode_quotes]
-
-          encoded = encoded.gsub("\u00A0", '&nbsp;') if options[:encode_nbsp]
-
-          encoded
-        end
-
-        # Decode HTML entities to text
-        def decode(text)
-          return '' if text.nil?
-          return text unless text.is_a?(String)
-
-          decoded = text.dup
-
-          # Decode named entities
-          NAMED_ENTITIES.each do |name, char|
-            decoded = decoded.gsub("&#{name};", char)
-          end
-
-          # Decode numeric entities (decimal)
-          decoded = decoded.gsub(/&#(\d+);/) do
-            [::Regexp.last_match(1).to_i].pack('U')
-          end
-
-          # Decode numeric entities (hexadecimal)
-          decoded = decoded.gsub(/&#x([0-9a-fA-F]+);/) do
-            [::Regexp.last_match(1).to_i(16)].pack('U')
-          end
-
-          # Decode basic entities last
-          decoded
-            .gsub('&quot;', '"')
-            .gsub('&#39;', "'")
-            .gsub('&#x27;', "'")
-            .gsub('&lt;', '<')
-            .gsub('&gt;', '>')
-            .gsub('&amp;', '&')
-        end
-
-        # Convert character to named entity if available
-        def to_named_entity(char)
-          entity_name = NAMED_ENTITIES.key(char)
-          entity_name ? "&#{entity_name};" : char
-        end
-
-        # Convert character to numeric entity
-        def to_numeric_entity(char, format: :decimal)
-          codepoint = char.ord
-
-          case format
-          when :decimal
-            "&##{codepoint};"
-          when :hex, :hexadecimal
-            "&#x#{codepoint.to_s(16)};"
-          else
-            char
-          end
-        end
-
-        # Check if text contains HTML entities
-        def has_entities?(text)
-          return false unless text.is_a?(String)
-
-          text.match?(/&[a-zA-Z]+;|&#\d+;|&#x[0-9a-fA-F]+;/)
-        end
-
-        # Normalize entities (convert all to named where possible, numeric otherwise)
-        def normalize(text)
-          return '' if text.nil?
-          return text unless text.is_a?(String)
-
-          # First decode to get actual characters
-          decoded = decode(text)
-
-          # Then encode back using named entities where possible
-          decoded.chars.map do |char|
-            case char
-            when '&', '<', '>', '"', "'"
-              encode(char)
-            else
-              named = to_named_entity(char)
-              named == char ? char : named
-            end
-          end.join
-        end
-      end
-    end
-  end
-end

data/lib/coradoc/html/input/converters/ignore.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Ignore < Base
-          def to_coradoc(node, state = {})
-            convert(node, state)
-          end
-
-          def convert(_node, _state = {})
-            '' # noop
-          end
-        end
-
-        register :colgroup, Ignore.new
-        register :col,      Ignore.new
-      end
-    end
-  end
-end

data/lib/coradoc/html/input/converters/th.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Th < Td
-          def cellstyle(node)
-            # this is the header row
-            return '' if node.parent.previous_element.nil?
-
-            'h'
-          end
-        end
-
-        register :th, Th.new
-      end
-    end
-  end
-end

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

@@ -1,231 +0,0 @@
-# frozen_string_literal: true
-
-require 'coradoc/html/base'
-
-module Coradoc
-  module Html
-    module Theme
-      # Abstract base class for all HTML themes
-      #
-      # This class defines the interface that all theme renderers must implement.
-      # Themes are responsible for converting Coradoc document models to HTML output.
-      #
-      # @abstract Subclass and implement {#render} to create a custom theme
-      class Base
-        attr_reader :document, :options
-
-        # Initialize a new theme instance
-        #
-        # @param document [Coradoc::CoreModel::StructuralElement] The document to render
-        # @param options [Hash] Rendering options
-        def initialize(document, options = {})
-          @document = document
-          @options = options
-        end
-
-        # Render the document to HTML
-        #
-        # This method must be implemented by subclasses.
-        #
-        # @abstract
-        # @return [String] The rendered HTML content
-        def render
-          raise NotImplementedError,
-                "#{self.class.name} must implement #render method"
-        end
-
-        # Render the complete HTML5 document
-        #
-        # @return [String] Complete HTML5 document
-        def render_html5
-          html_body = render
-          build_html5_document(html_body)
-        end
-
-        # Get the theme name
-        #
-        # @return [Symbol] Theme name (e.g., :classic, :modern)
-        def theme_name
-          @theme_name ||= self.class.name.split('::').last
-                              .gsub(/Renderer$/, '')
-                              .downcase
-                              .to_sym
-        end
-
-        # Check if this theme supports a specific feature
-        #
-        # @param feature [Symbol] Feature to check (e.g., :dark_mode, :interactive_toc)
-        # @return [Boolean] true if the feature is supported
-        def supports?(feature)
-          supported_features.include?(feature)
-        end
-
-        # List of features supported by this theme
-        #
-        # Subclasses can override to declare supported features.
-        #
-        # @return [Array<Symbol>] List of supported features
-        def supported_features
-          []
-        end
-
-        protected
-
-        # Build complete HTML5 document
-        #
-        # @param body_html [String] HTML body content
-        # @return [String] Complete HTML5 document
-        def build_html5_document(body_html)
-          lang = @options[:lang] || 'en'
-          body_classes = build_body_classes
-
-          <<~HTML
-            <!DOCTYPE html>
-            <html lang="#{lang}">
-            <head>
-            #{build_head_content}
-            </head>
-            <body#{body_classes}>
-            #{body_html}
-            </body>
-            </html>
-          HTML
-        end
-
-        # Build HTML head content
-        #
-        # @return [String] Head section HTML
-        def build_head_content
-          parts = []
-          parts << build_meta_tags
-          parts << build_title_tag
-          parts << build_css_tags
-          parts << build_script_tags
-          parts.compact.reject(&:empty?).join("\n")
-        end
-
-        # Build meta tags
-        #
-        # @return [String] Meta tags HTML
-        def build_meta_tags
-          meta = []
-          meta << '  <meta charset="UTF-8">'
-          meta << '  <meta name="viewport" content="width=device-width, initial-scale=1.0">'
-
-          # Author meta tag
-          if @options[:author]
-            author = escape_attr(@options[:author])
-            meta << %(  <meta name="author" content="#{author}">)
-          end
-
-          # Description meta tag
-          if @options[:description]
-            description = escape_attr(@options[:description])
-            meta << %(  <meta name="description" content="#{description}">)
-          end
-
-          # Keywords meta tag
-          if @options[:keywords]
-            keywords = escape_attr(@options[:keywords])
-            meta << %(  <meta name="keywords" content="#{keywords}">)
-          end
-
-          # Generator meta tag with version
-          meta << %(  <meta name="generator" content="Coradoc #{Coradoc::VERSION}">)
-
-          # Generation timestamp
-          meta << %(  <meta name="generated" content="#{Time.now.utc.iso8601}">)
-
-          # Custom meta tags
-          if @options[:meta_tags].is_a?(Hash)
-            @options[:meta_tags].each do |name, content|
-              meta << %(  <meta name="#{escape_attr(name)}" content="#{escape_attr(content)}">)
-            end
-          end
-
-          meta.join("\n")
-        end
-
-        # Build title tag
-        #
-        # @return [String] Title tag HTML
-        def build_title_tag
-          title = extract_document_title
-          "  <title>#{escape_html(title)}</title>"
-        end
-
-        # Extract document title
-        #
-        # @return [String] Document title
-        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
-
-        # Extract text from content (array of inline elements)
-        #
-        # @param content [Array] Content elements
-        # @return [String] Extracted text
-        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.text
-          else
-            content.to_s
-          end
-        end
-
-        # Build body classes
-        #
-        # @return [String] Body class attribute
-        def build_body_classes
-          classes = []
-          classes << "theme-#{theme_name}"
-
-          classes.empty? ? '' : %( class="#{classes.join(' ')}")
-        end
-
-        # Build CSS tags
-        #
-        # @return [String] CSS link or style tags
-        def build_css_tags
-          ''
-        end
-
-        # Build script tags
-        #
-        # @return [String] Script tags
-        def build_script_tags
-          ''
-        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;')
-        end
-      end
-    end
-  end
-end