docbook 0.1.0

data/lib/docbook/services/element_to_hash.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module Docbook
+  module Services
+    # Converts Lutaml elements to Vue-friendly hashes
+    # Uses Lutaml's as_json but ensures compatibility with Vue rendering
+    class ElementToHash
+      def initialize(element)
+        @element = element
+      end
+
+      # Convert element to hash suitable for Vue
+      def to_h
+        case @element
+        when Elements::RefEntry
+          refentry_to_h
+        when Elements::Para
+          para_to_h
+        when Elements::VariableList
+          variablelist_to_h
+        when Elements::OrderedList
+          orderedlist_to_h
+        when Elements::ItemizedList
+          itemizedlist_to_h
+        when Elements::ProgramListing, Elements::Screen
+          codelike_to_h
+        when Elements::Example, Elements::InformalExample
+          example_to_h
+        when Elements::Figure, Elements::InformalFigure
+          figure_to_h
+        when Elements::Table
+          table_to_h
+        when Elements::Note, Elements::Warning, Elements::Caution,
+             Elements::Important, Elements::Tip, Elements::Danger
+          admonition_to_h
+        when Elements::BlockQuote
+          blockquote_to_h
+        when Elements::Title
+          { type: "title", text: @element.content }
+        else
+          generic_to_h
+        end
+      end
+
+      private
+
+      def refentry_to_h
+        content = @element.as_json
+
+        # Flatten for Vue - extract key fields
+        result = {
+          type: "refentry",
+          id: @element.xml_id
+        }
+
+        # Extract refmeta info
+        if @element.refmeta
+          result[:refentrytitle] = @element.refmeta.refentrytitle&.content
+          result[:refmiscinfo] = @element.refmeta.refmiscinfo&.map(&:content)
+        end
+
+        # Extract refnamediv info
+        if @element.refnamediv
+          result[:refname] = @element.refnamediv.refname&.map(&:content)&.join(" ")
+          result[:refpurpose] = @element.refnamediv.refpurpose&.content
+          result[:refclass] = @element.refnamediv.refclass&.content
+        end
+
+        # Convert refsection content
+        if @element.refsection&.any?
+          result[:sections] = @element.refsection.map do |rs|
+            section_content_to_h(rs)
+          end
+        end
+
+        result
+      end
+
+      def section_content_to_h(section)
+        children = []
+
+        # Process all child elements
+        if section.respond_to?(:elements)
+          section.elements.each do |el|
+            children << ElementToHash.new(el).to_h
+          end
+        end
+
+        { type: "section", children: children }
+      end
+
+      def para_to_h
+        content = extract_inline_content(@element)
+        {
+          type: "para",
+          content: content
+        }
+      end
+
+      def variablelist_to_h
+        {
+          type: "variablelist",
+          items: @element.varlistentry.map do |ve|
+            terms = ve.term&.map { |t| extract_inline_content(t) } || []
+            definition = if ve.listitem&.respond_to?(:para)
+              ve.listitem.para.map { |p| extract_inline_content(p) }
+            elsif ve.listitem&.respond_to?(:elements)
+              ve.listitem.elements.map { |e| ElementToHash.new(e).to_h }
+            else
+              []
+            end
+            { terms: terms, definition: definition }
+          end
+        }
+      end
+
+      def orderedlist_to_h
+        {
+          type: "orderedlist",
+          items: @element.listitem.map do |li|
+            items = []
+            if li.respond_to?(:para)
+              items = li.para.map { |p| extract_inline_content(p) }
+            elsif li.respond_to?(:elements)
+              items = li.elements.map { |e| ElementToHash.new(e).to_h }
+            end
+            items
+          end
+        }
+      end
+
+      def itemizedlist_to_h
+        {
+          type: "itemizedlist",
+          items: @element.listitem.map do |li|
+            items = []
+            if li.respond_to?(:para)
+              items = li.para.map { |p| extract_inline_content(p) }
+            elsif li.respond_to?(:elements)
+              items = li.elements.map { |e| ElementToHash.new(e).to_h }
+            end
+            items
+          end
+        }
+      end
+
+      def codelike_to_h
+        code_text = build_code_text
+        {
+          type: "code",
+          text: code_text,
+          language: @element.language
+        }
+      end
+
+      def example_to_h
+        {
+          type: "example",
+          content: @element.elements.map { |e| ElementToHash.new(e).to_h }
+        }
+      end
+
+      def figure_to_h
+        result = {
+          type: "figure",
+          id: @element.xml_id
+        }
+
+        if @element.respond_to?(:mediaobject) && @element.mediaobject
+          obj = @element.mediaobject
+          if obj.respond_to?(:imageobject) && obj.imageobject&.first
+            imagedata = obj.imageobject.first.imagedata
+            result[:src] = imagedata&.fileref
+            result[:alt] = obj.imageobject.first.textobject&.phrase&.content
+          end
+        end
+
+        result
+      end
+
+      def table_to_h
+        # Simplified table representation
+        {
+          type: "table",
+          id: @element.xml_id,
+          rows: []  # Would need complex traversal
+        }
+      end
+
+      def admonition_to_h
+        title = @element.respond_to?(:title) ? @element.title&.content : nil
+        content = @element.elements.map { |e| ElementToHash.new(e).to_h } if @element.elements
+
+        {
+          type: @element.class.name.split('::').last.downcase,
+          title: title,
+          content: content
+        }
+      end
+
+      def blockquote_to_h
+        attribution = @element.attribution&.content if @element.attribution
+        content = @element.elements.map { |e| ElementToHash.new(e).to_h } if @element.elements
+
+        {
+          type: "blockquote",
+          attribution: attribution,
+          content: content
+        }
+      end
+
+      def generic_to_h
+        # Default: try to use as_json
+        if @element.respond_to?(:as_json)
+          @element.as_json.merge(type: @element.class.name.split('::').last.downcase)
+        else
+          { type: "unknown", content: @element.to_s }
+        end
+      end
+
+      def extract_inline_content(element)
+        return [] unless element
+
+        content = []
+        if element.respond_to?(:content)
+          c = element.content
+          if c.is_a?(Array)
+            c.each { |item| content << process_inline_item(item) }
+          elsif c.is_a?(String)
+            content << { type: "text", value: c }
+          end
+        elsif element.respond_to?(:elements)
+          element.elements.each do |el|
+            content << process_inline_item(el)
+          end
+        end
+        content
+      end
+
+      def process_inline_item(item)
+        case item
+        when String
+          { type: "text", value: item }
+        when Elements::Emphasis
+          {
+            type: "emphasis",
+            role: item.role,
+            content: extract_inline_content(item)
+          }
+        when Elements::Link
+          {
+            type: "link",
+            href: item.href,
+            content: extract_inline_content(item)
+          }
+        when Elements::Xref
+          {
+            type: "xref",
+            linkend: item.linkend,
+            content: item.content || item.linkend
+          }
+        when Elements::Literal, Elements::Code
+          { type: "codetext", value: item.content }
+        when Elements::Tag
+          { type: "tag", value: "<#{item.content}>" }
+        when Elements::Quote
+          { type: "quote", value: item.content }
+        else
+          if item.respond_to?(:content)
+            { type: "text", value: item.content.to_s }
+          else
+            { type: "text", value: item.to_s }
+          end
+        end
+      end
+
+      def build_code_text
+        if @element.respond_to?(:content)
+          c = @element.content
+          c.is_a?(Array) ? c.join : c.to_s
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/docbook/services/index_generator.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Docbook
+  module Services
+    # Generates index entries from IndexTerm elements in the document
+    class IndexGenerator
+      def initialize(document)
+        @document = document
+        @entries = []
+      end
+
+      def generate
+        @entries = []
+        collect_index_terms(@document)
+        sort_entries!
+        @entries
+      end
+
+      private
+
+      def collect_index_terms(element, section_info = {})
+        return unless element
+
+        # Extract section info from current element
+        section_info = extract_section_info(element) if section_info.empty?
+
+        # Process index terms at this level
+        process_index_terms(element, section_info)
+
+        # Recurse into children
+        if element.respond_to?(:elements)
+          Array(element.elements).each do |child|
+            collect_index_terms(child, section_info)
+          end
+        end
+
+        # Process nested sections
+        if element.respond_to?(:section)
+          Array(element.section).each do |section|
+            collect_index_terms(section, section_info)
+          end
+        end
+      end
+
+      def extract_section_info(element)
+        {
+          section_id: element.xml_id || generate_id(element),
+          section_title: get_element_title(element)
+        }
+      end
+
+      def get_element_title(element)
+        case element
+        when Elements::RefEntry
+          element.refnamediv&.refname&.map(&:content)&.join(" ") ||
+            element.refmeta&.refentrytitle&.content
+        else
+          element.respond_to?(:title) && element.title&.content ||
+            element.respond_to?(:info) && element.info&.title&.content
+        end
+      end
+
+      def generate_id(element)
+        "section-#{element.class.name.split('::').last.downcase}-#{element.object_id}"
+      end
+
+      def process_index_terms(element, section_info)
+        # Find indexterm elements
+        index_terms = find_index_terms(element)
+
+        index_terms.each do |term|
+          entry = build_index_entry(term, section_info)
+          @entries << entry if entry
+        end
+      end
+
+      def find_index_terms(element)
+        return [] unless element
+
+        terms = []
+        if element.is_a?(Elements::IndexTerm)
+          terms << element
+        end
+
+        # Check for nested index terms
+        if element.respond_to?(:indexterm)
+          terms.concat(Array(element.indexterm))
+        end
+
+        terms
+      end
+
+      def build_index_entry(index_term, section_info)
+        primary = extract_primary(index_term)
+        return nil unless primary
+
+        entry = Models::IndexEntry.new(
+          primary: primary,
+          section_id: section_info[:section_id],
+          section_title: section_info[:section_title],
+          sort_key: primary.downcase.strip
+        )
+
+        # Extract secondary terms
+        if index_term.respond_to?(:secondary)
+          entry.secondary = Array(index_term.secondary).map(&:content).compact
+        end
+
+        # Extract see-also
+        if index_term.respond_to?(:see_also)
+          entry.see_also = Array(index_term.see_also).map(&:content).compact
+        end
+
+        entry
+      end
+
+      def extract_primary(index_term)
+        # Primary is typically in the content or primary attribute
+        if index_term.respond_to?(:primary) && index_term.primary
+          Array(index_term.primary).map(&:content).join(" ")
+        elsif index_term.respond_to?(:content)
+          content = index_term.content
+          content.is_a?(Array) ? content.join(" ") : content.to_s
+        elsif index_term.respond_to?(:to_s)
+          index_term.to_s
+        end
+      end
+
+      def sort_entries!
+        @entries.sort_by!(&:sort_key)
+      end
+    end
+  end
+end

data/lib/docbook/services/numbering_service.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Docbook
+  module Services
+    # Pre-computes section numbering for the document
+    # Handles: Roman numerals for Parts, Arabic for Chapters,
+    #          Hierarchical for Sections, Alpha for Appendices
+    class NumberingService
+      def initialize(document)
+        @document = document
+        @numbering = []
+        @part_counter = 0
+        @chapter_counters = {}  # part_index => counter
+        @appendix_counter = 0
+        @section_counters = {}  # scope_id => [level1, level2, ...]
+      end
+
+      def generate
+        @numbering = []
+        @part_counter = 0
+        @chapter_counters = {}
+        @appendix_counter = 0
+        @section_counters = {}
+
+        process_document(@document)
+        @numbering
+      end
+
+      private
+
+      def process_document(element, parent_info = {})
+        return unless element
+
+        case element
+        when Elements::Part
+          process_part(element, parent_info)
+        when Elements::Chapter
+          process_chapter(element, parent_info)
+        when Elements::Appendix
+          process_appendix(element, parent_info)
+        when Elements::Section
+          process_section(element, parent_info)
+        when Elements::RefEntry
+          process_refentry(element, parent_info)
+        else
+          # Process children
+          process_children(element, parent_info)
+        end
+      end
+
+      def process_part(part, parent_info)
+        @part_counter += 1
+        part_number = roman_numeral(@part_counter)
+
+        add_numbering(part, part_number, "part")
+
+        # Track chapters within this part
+        @chapter_counters[@part_counter] = 0
+
+        process_children(part, parent_info.merge(part_counter: @part_counter))
+      end
+
+      def process_chapter(chapter, parent_info)
+        part_idx = parent_info[:part_counter] || 0
+        @chapter_counters[part_idx] ||= 0
+        @chapter_counters[part_idx] += 1
+        chapter_number = @chapter_counters[part_idx].to_s
+
+        add_numbering(chapter, chapter_number, "chapter")
+
+        # Reset section counters for this chapter
+        scope_id = chapter.xml_id || "chapter-#{chapter_number}"
+        @section_counters[scope_id] = [0, 0, 0, 0, 0]
+
+        process_children(chapter, parent_info.merge(chapter_scope: scope_id))
+      end
+
+      def process_appendix(appendix, parent_info)
+        @appendix_counter += 1
+        appendix_number = alpha_numeral(@appendix_counter)
+
+        add_numbering(appendix, appendix_number, "appendix")
+
+        # Reset section counters for this appendix
+        scope_id = appendix.xml_id || "appendix-#{appendix_number}"
+        @section_counters[scope_id] = [0, 0, 0, 0, 0]
+
+        process_children(appendix, parent_info.merge(appendix_scope: scope_id))
+      end
+
+      def process_section(section, parent_info)
+        # Determine scope
+        scope_id = parent_info[:chapter_scope] ||
+                    parent_info[:appendix_scope] ||
+                    section.xml_id ||
+                    "section-#{@numbering.length}"
+
+        # Initialize counters for this scope
+        @section_counters[scope_id] ||= [0, 0, 0, 0, 0]
+
+        # Count nesting depth
+        depth = section_depth(section)
+
+        # Increment counter at this depth
+        @section_counters[scope_id][depth - 1] += 1
+
+        # Reset counters for deeper levels
+        (depth...5).each { |i| @section_counters[scope_id][i] = 0 }
+
+        # Build number string
+        numbers = @section_counters[scope_id].first(depth)
+        section_number = numbers.join(".")
+
+        add_numbering(section, section_number, "section")
+
+        process_children(section, parent_info)
+      end
+
+      def process_refentry(refentry, parent_info)
+        refname = if refentry.refnamediv&.refname
+          refentry.refnamediv.refname.map(&:content).join(" ")
+        elsif refentry.refmeta&.refentrytitle
+          refentry.refmeta.refentrytitle.content
+        else
+          refentry.xml_id || "refentry"
+        end
+
+        add_numbering(refentry, refname, "refentry")
+      end
+
+      def process_children(element, parent_info)
+        return unless element.respond_to?(:elements)
+
+        Array(element.elements).each do |child|
+          process_document(child, parent_info)
+        end
+      end
+
+      def section_depth(section)
+        # Determine section nesting depth
+        depth = 1
+        el = section
+        while el.respond_to?(:parent) && el.parent
+          depth += 1
+          el = el.parent
+        end
+        [depth, 5].min
+      end
+
+      def add_numbering(element, number, type)
+        @numbering << Models::SectionNumber.new(
+          id: element.xml_id || "element-#{@numbering.length}",
+          number: number.to_s,
+          type: type
+        )
+      end
+
+      def roman_numeral(num)
+        result = +""
+        roman_map = {
+          1000 => 'M', 900 => 'CM', 500 => 'D', 400 => 'CD',
+          100 => 'C', 90 => 'XC', 50 => 'L', 40 => 'XL',
+          10 => 'X', 9 => 'IX', 5 => 'V', 4 => 'IV', 1 => 'I'
+        }
+        remaining = num
+        roman_map.each do |value, letter|
+          while remaining >= value
+            result << letter
+            remaining -= value
+          end
+        end
+        result
+      end
+
+      def alpha_numeral(num)
+        result = ""
+        while num > 0
+          num -= 1
+          result = (('A'.ord + (num % 26)).chr) + result
+          num /= 26
+        end
+        result
+      end
+    end
+  end
+end