docbook 0.1.0

data/lib/docbook/output/index_generator.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Docbook
+  module Output
+    # Collects all indexterms from a document for index generation
+    class IndexCollector
+      def initialize(document)
+        @document = document
+        @index_terms = []
+      end
+
+      # Collect all indexterms from the document
+      def collect
+        @index_terms = []
+        traverse_element(@document)
+        @index_terms
+      end
+
+      # Get indexterms grouped by type
+      def by_type
+        result = {}
+        @index_terms.each do |term|
+          type = term[:type] || "default"
+          result[type] ||= []
+          result[type] << term
+        end
+        result
+      end
+
+      private
+
+      def traverse_element(element, section_info = {})
+        return unless element
+
+        # Collect section info for linking based on element type
+        section_info = update_section_info(element, section_info)
+
+        # Check for indexterm on this element
+        each_attr(element, :indexterm) do |it|
+          process_indexterm(it, section_info)
+        end
+
+        # Traverse children based on element type
+        case element
+        when Elements::Book
+          traverse_book(element, section_info)
+        when Elements::Part
+          traverse_part(element, section_info)
+        when Elements::Article
+          traverse_article(element, section_info)
+        when Elements::Chapter
+          traverse_chapter(element, section_info)
+        when Elements::Appendix
+          traverse_appendix(element, section_info)
+        when Elements::Section
+          traverse_section(element, section_info)
+        when Elements::Simplesect
+          traverse_simplesect(element, section_info)
+        when Elements::RefEntry
+          traverse_refentry(element, section_info)
+        when Elements::RefSection
+          traverse_refsection(element, section_info)
+        when Elements::Para
+          # Para children are handled via mixed content traversal
+          traverse_mixed_content(element, section_info)
+        when Elements::ListItem
+          traverse_listitem(element, section_info)
+        when Elements::Entry
+          traverse_entry(element, section_info)
+        end
+      end
+
+      def update_section_info(element, current_info)
+        info = current_info.dup
+        if element.xml_id
+          info[:id] = element.xml_id
+          info[:title] = element_title(element)
+        elsif element.respond_to?(:title) && element.title
+          info[:title] = element.title.content.to_s
+        end
+        info
+      end
+
+      def traverse_book(book, section_info)
+        each_attr(book, :part) { |p| traverse_element(p, section_info) }
+        each_attr(book, :chapter) { |c| traverse_element(c, section_info) }
+        each_attr(book, :appendix) { |a| traverse_element(a, section_info) }
+        each_attr(book, :preface) { |p| traverse_element(p, section_info) }
+        each_attr(book, :glossary) { |g| traverse_element(g, section_info) }
+        each_attr(book, :bibliography) { |b| traverse_element(b, section_info) }
+        each_attr(book, :index) { |i| traverse_element(i, section_info) }
+        each_attr(book, :setindex) { |si| traverse_element(si, section_info) }
+      end
+
+      def traverse_part(part, section_info)
+        each_attr(part, :part) { |p| traverse_element(p, section_info) }
+        each_attr(part, :chapter) { |c| traverse_element(c, section_info) }
+        each_attr(part, :appendix) { |a| traverse_element(a, section_info) }
+        each_attr(part, :reference) { |r| traverse_element(r, section_info) }
+        each_attr(part, :preface) { |p| traverse_element(p, section_info) }
+        each_attr(part, :glossary) { |g| traverse_element(g, section_info) }
+        each_attr(part, :bibliography) { |b| traverse_element(b, section_info) }
+        each_attr(part, :index) { |i| traverse_element(i, section_info) }
+        each_attr(part, :setindex) { |si| traverse_element(si, section_info) }
+      end
+
+      def traverse_article(article, section_info)
+        each_attr(article, :section) { |s| traverse_element(s, section_info) }
+        each_attr(article, :glossary) { |g| traverse_element(g, section_info) }
+        each_attr(article, :bibliography) { |b| traverse_element(b, section_info) }
+        each_attr(article, :index) { |i| traverse_element(i, section_info) }
+      end
+
+      def traverse_chapter(chapter, section_info)
+        each_attr(chapter, :section) { |s| traverse_element(s, section_info) }
+        each_attr(chapter, :simplesect) { |ss| traverse_element(ss, section_info) }
+        each_attr(chapter, :para) { |p| traverse_element(p, section_info) }
+        each_attr(chapter, :indexterm) { |it| process_indexterm(it, section_info) }
+      end
+
+      def traverse_appendix(appendix, section_info)
+        each_attr(appendix, :section) { |s| traverse_element(s, section_info) }
+        each_attr(appendix, :simplesect) { |ss| traverse_element(ss, section_info) }
+        each_attr(appendix, :para) { |p| traverse_element(p, section_info) }
+        each_attr(appendix, :indexterm) { |it| process_indexterm(it, section_info) }
+      end
+
+      def traverse_section(section, section_info)
+        each_attr(section, :section) { |s| traverse_element(s, section_info) }
+        each_attr(section, :simplesect) { |ss| traverse_element(ss, section_info) }
+        each_attr(section, :para) { |p| traverse_element(p, section_info) }
+        each_attr(section, :indexterm) { |it| process_indexterm(it, section_info) }
+      end
+
+      def traverse_simplesect(simplesect, section_info)
+        each_attr(simplesect, :para) { |p| traverse_element(p, section_info) }
+        each_attr(simplesect, :indexterm) { |it| process_indexterm(it, section_info) }
+      end
+
+      def traverse_refentry(refentry, section_info)
+        each_attr(refentry, :refsection) { |rs| traverse_element(rs, section_info) }
+      end
+
+      def traverse_refsection(refsection, section_info)
+        new_info = update_section_info(refsection, section_info)
+        each_attr(refsection, :para) { |p| traverse_element(p, new_info) }
+        each_attr(refsection, :indexterm) { |it| process_indexterm(it, new_info) }
+      end
+
+      def traverse_listitem(listitem, section_info)
+        each_attr(listitem, :para) { |p| traverse_element(p, section_info) }
+        each_attr(listitem, :simplesect) { |ss| traverse_element(ss, section_info) }
+        each_attr(listitem, :indexterm) { |it| process_indexterm(it, section_info) }
+      end
+
+      def traverse_entry(entry, section_info)
+        each_attr(entry, :para) { |p| traverse_element(p, section_info) }
+        each_attr(entry, :indexterm) { |it| process_indexterm(it, section_info) }
+      end
+
+      def traverse_mixed_content(element, section_info)
+        return unless element.respond_to?(:each_mixed_content)
+
+        element.each_mixed_content do |node|
+          case node
+          when Elements::IndexTerm
+            process_indexterm(node, section_info)
+          when Elements::Para
+            traverse_element(node, section_info)
+          end
+        end
+      end
+
+      def process_indexterm(indexterm, section_info)
+        # Skip if no primary (required for meaningful index entry)
+        primaries = Array(indexterm.primary).map { |p| p.content.to_s.strip }.compact
+        return if primaries.empty?
+
+        primary_text = primaries.first
+        secondaries = Array(indexterm.secondary).map { |s| s.content.to_s.strip }.compact
+        tertiaries = Array(indexterm.tertiary).map { |t| t.content.to_s.strip }.compact
+
+        sees = Array(indexterm.see).map { |s| s.content.to_s.strip }.compact
+        see_alsos = Array(indexterm.see_also).map { |sa| sa.content.to_s.strip }.compact
+
+        term_info = {
+          primary: primary_text,
+          primary_sort: sort_key(primary_text, indexterm),
+          secondary: secondaries.first,
+          tertiary: tertiaries.first,
+          sees: sees,
+          see_alsos: see_alsos,
+          type: indexterm.type,
+          zone: indexterm.zone,
+          xml_id: indexterm.xml_id,
+          class_value: indexterm.class_value,
+          section_id: section_info[:id],
+          section_title: section_info[:title],
+          section_info: section_info
+        }
+
+        @index_terms << term_info
+      end
+
+      def element_title(element)
+        case element
+        when Elements::Book, Elements::Article
+          element.info&.title&.content
+        when Elements::Chapter, Elements::Appendix, Elements::Section,
+             Elements::Part, Elements::Preface
+          element.info&.title&.content || element.title&.content
+        when Elements::RefEntry
+          element.refnamediv&.refname&.first&.content
+        else
+          element.title&.content
+        end
+      end
+
+      # Generate sort key for an index entry
+      def sort_key(text, indexterm)
+        return "SYMBOLS" if indexterm.class_value == "token" || text.start_with?("@")
+
+        # Remove leading punctuation for sorting
+        text.gsub(/^[^a-zA-Z]+/, "").downcase
+      end
+
+      # Helper to safely call attributes - same pattern as Html class
+      def each_attr(obj, name)
+        val = obj.send(name)
+        return unless val
+        Array(val).each { |item| yield item }
+      rescue NoMethodError
+        nil
+      end
+    end
+
+    # Generates index content from collected indexterms
+    class IndexGenerator
+      def initialize(index_terms, xref_resolver = nil)
+        @index_terms = index_terms
+        @xref_resolver = xref_resolver
+      end
+
+      # Generate index data structure grouped by letter
+      def generate
+        by_letter = group_by_letter
+        by_letter.sort_by { |letter, _| letter == "SYMBOLS" ? "{" : letter.downcase }
+              .to_h
+              .map do |letter, terms|
+            {
+              letter: letter,
+              entries: sort_entries(terms)
+            }
+          end
+      end
+
+      private
+
+      def group_by_letter
+        result = {}
+        @index_terms.each do |term|
+          letter = letter_for(term[:primary_sort])
+          result[letter] ||= []
+          result[letter] << term
+        end
+        result
+      end
+
+      def letter_for(sort_key)
+        return "SYMBOLS" if sort_key == "SYMBOLS" || sort_key.start_with?("@")
+
+        first_char = sort_key.chars.find(&:letter?) || sort_key[0] || ""
+        first_char.upcase
+      end
+
+      def sort_entries(terms)
+        terms.sort_by { |t| [t[:primary_sort], t[:secondary].to_s] }
+      end
+    end
+  end
+end

data/lib/docbook/output.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Docbook
+  module Output
+    autoload :Html, "#{__dir__}/output/html"
+    autoload :Data, "#{__dir__}/output/data"
+  end
+end

data/lib/docbook/services/document_builder.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Docbook
+  module Services
+    # Builds the complete DocumentRoot from a parsed Docbook document
+    class DocumentBuilder
+      def initialize(document, options = {})
+        @document = document
+        @options = options
+      end
+
+      def build
+        doc_root = Models::DocumentRoot.new(
+          title: extract_title,
+          metadata: build_metadata,
+          toc: generate_toc,
+          sections: build_sections,
+          index: generate_index,
+          numbering: generate_numbering,
+          generator: "docbook-gem/#{Docbook::VERSION}",
+          generated_at: Time.now.utc.iso8601
+        )
+      end
+
+      private
+
+      def extract_title
+        @document.respond_to?(:title) && @document.title&.content ||
+          @document.respond_to?(:info) && @document.info&.title&.content ||
+          "Untitled Document"
+      end
+
+      def build_metadata
+        metadata = Models::DocumentMetadata.new
+
+        if @document.respond_to?(:info)
+          info = @document.info
+          metadata.author = extract_author(info)
+          metadata.title = info.title&.content if info.respond_to?(:title)
+          metadata.subtitle = info.subtitle&.content if info.respond_to?(:subtitle)
+          metadata.productname = info.productname&.content if info.respond_to?(:productname)
+          metadata.pubdate = info.date&.content || info.pubdate&.content if info.respond_to?(:date) || info.respond_to?(:pubdate)
+        end
+
+        metadata
+      end
+
+      def extract_author(info)
+        return nil unless info.respond_to?(:author)
+
+        author = info.author
+        return nil unless author
+
+        if author.respond_to?(:personname)
+          author.personname&.content ||
+            [author.personname&.firstname&.content, author.personname&.surname&.content].compact.join(" ")
+        elsif author.respond_to?(:orgname)
+          author.orgname&.content
+        else
+          author.content
+        end
+      end
+
+      def generate_toc
+        TocGenerator.new(@document).generate
+      end
+
+      def generate_index
+        IndexGenerator.new(@document).generate
+      end
+
+      def generate_numbering
+        NumberingService.new(@document).generate
+      end
+
+      def build_sections
+        sections = []
+
+        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
+
+        root_elements.each do |element|
+          section = build_section(element)
+          sections << section if section
+        end
+
+        sections
+      end
+
+      def build_section(element)
+        type = element_type(element)
+        return nil unless type
+
+        section = Models::SectionRoot.new(
+          id: element.xml_id || generate_id(element),
+          type: type,
+          title: extract_element_title(element),
+          number: get_section_number(element)
+        )
+
+        # Convert content to hash
+        section.content = build_section_content(element)
+
+        # Process children
+        children = build_child_sections(element)
+        section.children = children if children.any?
+
+        # For refentry, extract refname
+        if element.is_a?(Elements::RefEntry)
+          section.refname = element.refnamediv&.refname&.map(&:content)&.join(" ") ||
+                            element.refmeta&.refentrytitle&.content
+        end
+
+        section
+      end
+
+      def element_type(element)
+        case element
+        when Elements::Part then "part"
+        when Elements::Chapter then "chapter"
+        when Elements::Appendix then "appendix"
+        when Elements::Section then "section"
+        when Elements::Reference then "reference"
+        when Elements::RefEntry then "refentry"
+        when Elements::Preface then "preface"
+        when Elements::Article then "article"
+        when Elements::Book then "book"
+        else nil
+        end
+      end
+
+      def extract_element_title(element)
+        case element
+        when Elements::RefEntry
+          element.refnamediv&.refname&.map(&:content)&.join(" ") ||
+            element.refmeta&.refentrytitle&.content ||
+            "Untitled"
+        when Elements::Reference
+          element.info&.title&.content || element.title&.content || "Reference"
+        else
+          element.info&.title&.content ||
+            element.title&.content ||
+            "Untitled"
+        end
+      end
+
+      def generate_id(element)
+        "section-#{element.class.name.split('::').last.downcase}-#{element.object_id}"
+      end
+
+      def get_section_number(element)
+        # Will be filled in by numbering service
+        nil
+      end
+
+      def build_section_content(element)
+        # Use ElementToHash to convert child elements
+        blocks = []
+
+        if element.respond_to?(:elements)
+          element.elements.each do |child|
+            next if skip_element?(child)
+            block = ElementToHash.new(child).to_h
+            blocks << block if block
+          end
+        end
+
+        # For refentry, also process refsection
+        if element.is_a?(Elements::RefEntry)
+          element.refsection&.each do |rs|
+            rs.elements&.each do |child|
+              next if skip_element?(child)
+              block = ElementToHash.new(child).to_h
+              blocks << block if block
+            end
+          end
+        end
+
+        blocks
+      end
+
+      def skip_element?(element)
+        element.is_a?(Elements::Title) ||
+          element.is_a?(Elements::Info) ||
+          element.is_a?(Elements::IndexTerm) ||
+          element.is_a?(Elements::Simplesect) && element.title.nil?
+      end
+
+      def build_child_sections(element)
+        children = []
+
+        child_elements = get_child_elements(element)
+
+        child_elements.each do |child|
+          next unless section_like?(child)
+          section = build_section(child)
+          children << section if section
+        end
+
+        children
+      end
+
+      def get_child_elements(element)
+        case element
+        when Elements::Book
+          children = []
+          children.concat(Array(element.part))
+          children.concat(Array(element.chapter))
+          children.concat(Array(element.appendix))
+          children.concat(Array(element.preface))
+          children
+        when Elements::Article
+          children = []
+          children.concat(Array(element.section))
+          children.concat(Array(element.article))
+          children
+        when Elements::Part
+          children = []
+          children.concat(Array(element.chapter))
+          children.concat(Array(element.appendix))
+          children
+        when Elements::Chapter, Elements::Appendix, Elements::Preface
+          Array(element.section)
+        when Elements::Section
+          Array(element.section)
+        when Elements::Reference
+          Array(element.refentry)
+        else
+          []
+        end
+      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