docbook 0.1.0

data/lib/docbook/services/toc_generator.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Docbook
+  module Services
+    # Generates hierarchical TOC from document sections
+    class TocGenerator
+      def initialize(document)
+        @document = document
+      end
+
+      def generate
+        root_elements = get_root_elements
+        root_elements.map { |element| build_toc_node(element) }.compact
+      end
+
+      private
+
+      def get_root_elements
+        case @document
+        when Elements::Book
+          roots = []
+          roots.concat(Array(@document.part))
+          roots.concat(Array(@document.chapter))
+          roots.concat(Array(@document.appendix))
+          roots.concat(Array(@document.preface))
+          roots
+        when Elements::Article
+          roots = []
+          roots.concat(Array(@document.section))
+          roots.concat(Array(@document.article))
+          roots
+        else
+          Array(@document.elements)
+        end
+      end
+
+      def build_toc_node(element)
+        return nil unless can_have_title?(element)
+
+        node = Models::TocNode.new(
+          id: get_id(element),
+          title: get_title(element),
+          type: element_type(element),
+          number: nil  # Numbering added separately
+        )
+
+        # Recursively add children
+        children = get_child_sections(element)
+        if children.any?
+          node.children = children.map { |child| build_toc_node(child) }.compact
+        end
+
+        node
+      end
+
+      def can_have_title?(element)
+        element.respond_to?(:title) ||
+          element.respond_to?(:info) ||
+          element.respond_to?(:refnamediv)
+      end
+
+      def get_title(element)
+        case element
+        when Elements::RefEntry
+          # Use refname from refnamediv as title
+          if element.refnamediv&.refname
+            element.refnamediv.refname.map(&:content).join(" ")
+          elsif element.refmeta&.refentrytitle
+            element.refmeta.refentrytitle.content
+          else
+            "Untitled"
+          end
+        when Elements::Reference
+          element.info&.title&.content ||
+            element.title&.content ||
+            "Reference"
+        when Elements::Book, Elements::Article, Elements::Chapter, Elements::Appendix,
+             Elements::Preface, Elements::Part, Elements::Section
+          element.info&.title&.content ||
+            element.title&.content ||
+            "Untitled"
+        else
+          "Untitled"
+        end
+      end
+
+      def get_id(element)
+        element.xml_id || generate_id(element)
+      end
+
+      def generate_id(element)
+        # Generate a stable ID from class name
+        "section-#{element.class.name.split('::').last.downcase}"
+      end
+
+      def element_type(element)
+        element.class.name.split('::').last.downcase
+      end
+
+      def get_child_sections(element)
+        children = []
+
+        case element
+        when Elements::Book
+          # Book has specific child element collections
+          children.concat(Array(element.part))
+          children.concat(Array(element.chapter))
+          children.concat(Array(element.appendix))
+          children.concat(Array(element.preface))
+        when Elements::Article
+          children.concat(Array(element.section))
+          children.concat(Array(element.article))
+        when Elements::Part
+          children.concat(Array(element.chapter))
+          children.concat(Array(element.appendix))
+        when Elements::Chapter, Elements::Appendix, Elements::Preface
+          children.concat(Array(element.section))
+        when Elements::Section
+          children.concat(Array(element.section))
+        when Elements::Reference
+          children.concat(Array(element.refentry))
+        end
+
+        children.select { |e| section_like?(e) }
+      end
+
+      def section_like?(element)
+        element.is_a?(Elements::Section) ||
+          element.is_a?(Elements::Chapter) ||
+          element.is_a?(Elements::Appendix) ||
+          element.is_a?(Elements::Part) ||
+          element.is_a?(Elements::Reference) ||
+          element.is_a?(Elements::RefEntry) ||
+          element.is_a?(Elements::Preface)
+      end
+    end
+  end
+end

data/lib/docbook/services.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Docbook
+  module Services
+    # Service classes for data generation
+    SERVICES_DIR = "#{__dir__}/services"
+
+    autoload :TocGenerator, "#{SERVICES_DIR}/toc_generator"
+    autoload :IndexGenerator, "#{SERVICES_DIR}/index_generator"
+    autoload :NumberingService, "#{SERVICES_DIR}/numbering_service"
+    autoload :ElementToHash, "#{SERVICES_DIR}/element_to_hash"
+    autoload :DocumentBuilder, "#{SERVICES_DIR}/document_builder"
+  end
+end

data/lib/docbook/templates/document.html.liquid

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en" class="scroll-smooth">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{{ docbook_title | escape }}</title>
+  {% include 'partials/head' %}
+</head>
+<body class="bg-white dark:bg-gray-900 text-gray-900 dark:text-gray-100">
+  <div id="docbook-app"></div>
+  <script>
+  window.DOCBOOK_DATA = Object.assign([[DOCBOOK_DATA]], {
+    toc: [[DOCBOOK_TOC]],
+    content: [[DOCBOOK_CONTENT]],
+    index: [[DOCBOOK_INDEX]]
+  });
+  </script>
+  {% include 'partials/scripts' %}
+</body>
+</html>

data/lib/docbook/templates/partials/_head.liquid

@@ -0,0 +1,39 @@
+{% comment %}Prism.js for syntax highlighting{% endcomment %}
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css">
+
+{% comment %}Google Fonts{% endcomment %}
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Merriweather:ital,wght@0,400;0,700;1,400&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+
+{% comment %}Tailwind CDN{% endcomment %}
+<script src="https://cdn.tailwindcss.com"></script>
+<script>
+  tailwind.config = {
+    darkMode: 'class',
+    theme: {
+      extend: {
+        fontFamily: {
+          sans: ['Inter', 'system-ui', 'sans-serif'],
+          serif: ['Merriweather', 'Georgia', 'serif'],
+          mono: ['JetBrains Mono', 'ui-monospace', 'monospace'],
+        },
+      },
+    },
+  }
+</script>
+
+{% comment %}Custom styles{% endcomment %}
+<style>
+  [x-cloak] { display: none !important; }
+  .toc-active { color: #2563eb; background: #dbeafe; }
+  .dark .toc-active { color: #60a5fa; background: #1e3a5f; }
+  .db-bibentry { padding-left: 2em; text-indent: -2em; margin-bottom: 0.5em; }
+  .db-appendix { border-left: 4px solid #8b5cf6; padding-left: 1rem; margin-left: -1rem; }
+  .dark .db-appendix { border-left-color: #a78bfa; }
+</style>
+
+{% comment %}App CSS - inline for single_file, linked for directory{% endcomment %}
+{% if assets_inline %}
+<style>{{ app_css }}</style>
+{% else %}
+<link rel="stylesheet" href="{{ base_url }}/assets/app.css">
+{% endif %}

data/lib/docbook/templates/partials/_scripts.liquid

@@ -0,0 +1,10 @@
+{% comment %}Prism.js core + autoloader for additional languages{% endcomment %}
+<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/autoloader/prism-autoloader.min.js"></script>
+
+{% comment %}App JS - inline for single_file, linked for directory{% endcomment %}
+{% if assets_inline %}
+<script>{{ app_js }}</script>
+{% else %}
+<script src="{{ base_url }}/assets/app.iife.js"></script>
+{% endif %}

data/lib/docbook/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Docbook
+  VERSION = "0.1.0"
+end

data/lib/docbook/xinclude_resolver.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Docbook
+  class XIncludeResolver
+    XINCLUDE_NS = "http://www.w3.org/2001/XInclude"
+
+    # Resolve XInclude elements in a Nokogiri document.
+    # Handles standard XML includes, text includes, and text+fragid extensions.
+    # Processes iteratively to handle nested includes (e.g., file A includes file B
+    # which contains text+fragid self-references).
+    def self.resolve(doc)
+      loop do
+        includes = doc.xpath("//xi:include", "xi" => XINCLUDE_NS)
+        break if includes.empty?
+
+        resolved_any = false
+        includes.each do |inc|
+          href = inc["href"]
+          next unless href
+
+          parse_mode = inc["parse"] || "xml"
+          fragid = inc["fragid"]
+          base_dir = base_dir_for(inc.document)
+          file_path = resolve_path(base_dir, href)
+          next unless file_path && File.exist?(file_path)
+
+          if parse_mode == "text"
+            resolve_text_include(doc, inc, file_path, fragid)
+          else
+            resolve_xml_include(doc, inc, file_path)
+          end
+          resolved_any = true
+          break # re-scan after each resolve (tree changes)
+        end
+        break unless resolved_any
+      end
+      doc
+    rescue StandardError
+      doc
+    end
+
+    # Pre-process an XML string to resolve XIncludes before model parsing.
+    def self.resolve_string(xml_string, base_path: nil)
+      doc = if base_path
+              file_uri = "file://#{File.expand_path(base_path)}"
+              Nokogiri::XML(xml_string, file_uri)
+            else
+              Nokogiri::XML(xml_string)
+            end
+      resolve(doc)
+    end
+
+    # ── Include Resolution ──────────────────────────────────────────
+
+    def self.resolve_text_include(doc, inc, file_path, fragid)
+      content = File.read(file_path)
+      if fragid && !fragid.empty?
+        filtered = apply_fragid(content, fragid)
+        content = filtered if filtered
+      end
+      text_node = doc.create_text_node(content)
+      inc.replace(text_node)
+    end
+
+    def self.resolve_xml_include(doc, inc, file_path)
+      included_xml = File.read(file_path)
+      included_doc = Nokogiri::XML(included_xml, "file://#{File.expand_path(file_path)}")
+
+      root = included_doc.root
+      # Ensure namespace is declared in target document
+      if root.namespace
+        ns = root.namespace
+        existing = doc.root.namespace_definitions.find { |n| n.href == ns.href }
+        doc.root.add_namespace_definition(ns.prefix, ns.href) unless existing
+      end
+
+      # Replace the xi:include with the root element itself (not its children)
+      inc.replace(root.dup)
+    end
+
+    def self.base_dir_for(document)
+      url = document.url
+      return nil unless url
+      File.dirname(url.sub(%r{^file://}, ""))
+    end
+
+    def self.resolve_path(base_dir, href)
+      return nil unless base_dir
+      File.join(base_dir, href)
+    end
+
+    # ── Fragid Filtering ──────────────────────────────────────────
+
+    # Apply a fragid filter to text content
+    def self.apply_fragid(content, fragid)
+      if fragid.start_with?("search=")
+        apply_search_fragid(content, fragid[7..])
+      elsif fragid.start_with?("line=")
+        apply_line_fragid(content, fragid[5..])
+      elsif fragid.start_with?("char=")
+        apply_char_fragid(content, fragid[5..])
+      end
+    end
+
+    # Apply search= fragid scheme (DocBook xslTNG extension)
+    # Syntax: search=#PATTERN#[;after|;before],#STOP#
+    #   or:   search=/REGEX/[,/STOP/]
+    def self.apply_search_fragid(content, search_spec)
+      lines = content.lines
+      if search_spec.start_with?("/")
+        apply_delimited_search(lines, search_spec, "/")
+      elsif search_spec.start_with?("#")
+        apply_delimited_search(lines, search_spec, "#")
+      end
+    end
+
+    # Parse delimited patterns and apply search
+    # Delimiter is # (literal) or / (regex)
+    def self.apply_delimited_search(lines, spec, delim)
+      # Parse: DELIM pattern DELIM [;modifier] [, DELIM stop DELIM]
+      remainder = spec[1..] # skip opening delimiter
+      close_idx = remainder.index(delim)
+      return nil unless close_idx
+
+      pattern_str = remainder[0...close_idx]
+      remainder = remainder[(close_idx + 1)..]
+
+      # Check for modifier (;after or ;before)
+      modifier = nil
+      if remainder&.start_with?(";")
+        mod_match = remainder.match(/\A;(after|before)/)
+        if mod_match
+          modifier = mod_match[1].to_sym
+          remainder = remainder[mod_match[0].length..]
+        end
+      end
+
+      # Skip comma separator
+      remainder = remainder[1..] if remainder&.start_with?(",")
+
+      # Parse stop pattern if present
+      stop_pattern = nil
+      if remainder && !remainder.empty? && remainder.start_with?(delim)
+        stop_remainder = remainder[1..]
+        stop_close = stop_remainder.index(delim)
+        if stop_close
+          stop_pattern = stop_remainder[0...stop_close]
+        end
+      end
+
+      # Apply search
+      match_fn = delim == "/" ? ->(line, pat) { line.match?(Regexp.new(pat)) }
+                              : ->(line, pat) { line.include?(pat) }
+
+      start_idx = lines.index { |l| match_fn.call(l, pattern_str) }
+      return nil unless start_idx
+
+      # Determine range
+      case modifier
+      when :after
+        range_start = start_idx + 1
+      when :before
+        range_start = 0
+        range_end = start_idx
+      else
+        range_start = start_idx
+      end
+
+      # Find stop (exclusive)
+      if stop_pattern
+        stop_slice = lines[range_start..]
+        stop_idx = stop_slice&.index { |l| match_fn.call(l, stop_pattern) }
+        range_end = stop_idx ? range_start + stop_idx : lines.length
+      elsif modifier != :before
+        range_end = start_idx + 1
+      end
+
+      range_end ||= lines.length
+      selected = lines[range_start...range_end]
+      return nil unless selected && !selected.empty?
+
+      selected.join
+    end
+
+    # Apply line= fragid scheme (RFC 5147)
+    # Syntax: line=START,END[;length=N]
+    def self.apply_line_fragid(content, line_spec)
+      parts = line_spec.split(";")
+      range_part = parts[0]
+      length_part = parts.find { |p| p.start_with?("length=") }
+
+      line_start, line_end = range_part.split(",").map(&:to_i)
+      return nil unless line_start && line_end
+
+      lines = content.lines
+      selected = lines[(line_start - 1)...(line_end)]
+      return nil unless selected
+
+      result = selected.join
+      if length_part
+        max_len = length_part.split("=")[1].to_i
+        result = result[0...max_len] if max_len > 0
+      end
+      result
+    end
+
+    # Apply char= fragid scheme (RFC 5147)
+    # Syntax: char=START,END
+    def self.apply_char_fragid(content, char_spec)
+      char_start, char_end = char_spec.split(",").map(&:to_i)
+      return nil unless char_start && char_end
+      content[char_start...char_end]
+    end
+  end
+end

data/lib/docbook/xref_resolver.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Docbook
+  # Resolves xrefs in a DocBook document by building an O(1) xml:id lookup hash
+  # and resolving all xref/linkend references to their target titles.
+  class XrefResolver
+    def initialize(document)
+      @document = document
+      @xml_id_map = {}
+    end
+
+    # Build the xml:id -> element hash
+    def resolve!
+      @xml_id_map = build_xml_id_map(@document)
+      self
+    end
+
+    # Get the resolved title text for a linkend ID
+    def title_for(linkend)
+      target = @xml_id_map[linkend.to_s]
+      return nil unless target
+      best_title(target)
+    end
+
+    # Get element by xml:id
+    def [](xml_id)
+      @xml_id_map[xml_id.to_s]
+    end
+
+    private
+
+    def build_xml_id_map(el, map = {})
+      return map unless el.is_a?(Lutaml::Model::Serializable)
+
+      map[el.xml_id.to_s] = el if el.xml_id
+
+      # Walk child collections based on element type
+      case el
+      when Docbook::Elements::Book
+        el.part&.each { |p| build_xml_id_map(p, map) }
+        el.chapter&.each { |c| build_xml_id_map(c, map) }
+        el.appendix&.each { |a| build_xml_id_map(a, map) }
+        el.preface&.each { |p| build_xml_id_map(p, map) }
+        el.glossary&.each { |g| build_xml_id_map(g, map) }
+        el.bibliography&.each { |b| build_xml_id_map(b, map) }
+        el.index&.each { |i| build_xml_id_map(i, map) }
+      when Docbook::Elements::Article
+        el.section&.each { |s| build_xml_id_map(s, map) }
+      when Docbook::Elements::Part
+        el.chapter&.each { |c| build_xml_id_map(c, map) }
+        el.appendix&.each { |a| build_xml_id_map(a, map) }
+        el.reference&.each { |r| build_xml_id_map(r, map) }
+        el.glossary&.each { |g| build_xml_id_map(g, map) }
+        el.bibliography&.each { |b| build_xml_id_map(b, map) }
+        el.index&.each { |i| build_xml_id_map(i, map) }
+      when Docbook::Elements::Chapter, Docbook::Elements::Appendix,
+           Docbook::Elements::Section, Docbook::Elements::Preface
+        el.section&.each { |s| build_xml_id_map(s, map) }
+      when Docbook::Elements::Reference
+        el.refentry&.each { |r| build_xml_id_map(r, map) }
+      end
+
+      map
+    end
+
+    def best_title(el)
+      case el
+      when Docbook::Elements::Article, Docbook::Elements::Book
+        el.info&.title&.content
+      when Docbook::Elements::Section, Docbook::Elements::Chapter, Docbook::Elements::Appendix,
+           Docbook::Elements::Preface, Docbook::Elements::Part, Docbook::Elements::Reference
+        el.title&.content
+      else
+        el.title&.content rescue nil
+      end
+    end
+  end
+end

data/lib/docbook.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Docbook
+  class Error < StandardError; end
+
+  autoload :Version, "#{__dir__}/docbook/version"
+  autoload :Elements, "#{__dir__}/docbook/elements"
+  autoload :Models, "#{__dir__}/docbook/models"
+  autoload :Services, "#{__dir__}/docbook/services"
+  autoload :XIncludeResolver, "#{__dir__}/docbook/xinclude_resolver"
+  autoload :XrefResolver, "#{__dir__}/docbook/xref_resolver"
+  autoload :Output, "#{__dir__}/docbook/output"
+  autoload :CLI, "#{__dir__}/docbook/cli"
+  autoload :Document, "#{__dir__}/docbook/document"
+end

data/sig/docbook.rbs

@@ -0,0 +1,4 @@
+module Docbook
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end