arrolio 0.1.0 → 0.1.2

data/lib/arrolio/generic_adapter.rb

@@ -18,6 +18,24 @@ module Arrolio
   # hard-coded element names — every XML element/attribute the adapter
   # touches is named in the rules' `selectors` block.
   class GenericAdapter
+    autoload :InlineRunCollection, 'arrolio/generic_adapter/inline_run_collection'
+    autoload :HeadingExtraction, 'arrolio/generic_adapter/heading_extraction'
+    autoload :ListConversion, 'arrolio/generic_adapter/list_conversion'
+    autoload :MetadataExtraction, 'arrolio/generic_adapter/metadata_extraction'
+    autoload :DocumentExtraction, 'arrolio/generic_adapter/document_extraction'
+    autoload :FootnoteExtraction, 'arrolio/generic_adapter/footnote_extraction'
+
+    include FootnoteExtraction
+    include InlineRunCollection
+    include HeadingExtraction
+    include ListConversion
+    include MetadataExtraction
+    include DocumentExtraction
+
+    autoload :TableConversion, 'arrolio/generic_adapter/table_conversion'
+
+    include TableConversion
+
     DEFAULT_SELECTORS = {
       'heading' => 'fmt-title',
       'heading_depth_attribute' => 'depth',
@@ -56,6 +74,25 @@ module Arrolio
       'break_inline' => 'br'
     }.freeze
 
+    # Maps content_type (declared in rules.element_mapping) to a
+    # builder method. Adding a new content type = adding one entry
+    # here plus a builder method below — convert_children itself
+    # never needs to change (Open/Closed Principle).
+    CONVERTER_REGISTRY = {
+      'section' => :convert_section,
+      'paragraph' => :convert_paragraph,
+      'table' => :convert_table,
+      'figure' => :convert_figure,
+      'list' => :convert_list,
+      'term' => :convert_term,
+      'note' => :convert_note,
+      'example' => :convert_example,
+      'preformatted' => :convert_preformatted
+    }.freeze
+
+    XREF_ELEMENTS = ['fmt-xref-label', 'fmt-xref', 'xref'].freeze
+
+
     attr_reader :rules, :layout_spec, :selectors
 
     def initialize(rules:, layout_spec: nil)
@@ -76,7 +113,8 @@ module Arrolio
         preface: extract_preface(root),
         bibliography: extract_bibliography(root),
         cover: extract_cover(root),
-        footnotes: extract_footnotes(root)
+        footnotes: extract_footnotes(root),
+        title_block: extract_title_block(root)
       )
     end
 
@@ -88,136 +126,47 @@ module Arrolio
 
     # ---- Metadata extraction ----
 
-    def extract_metadata(root)
-      config = @rules['metadata'] || {}
-      bibdata_path = config['root'] || 'bibdata'
-      bibdata = find_first(root, bibdata_path)
-      return {} unless bibdata
 
-      result = {}
-      (config['fields'] || {}).each do |key, xpath|
-        value = text_of(find_first(bibdata, xpath))
-        result[key.to_sym] = value if value && !value.empty?
-      end
-      result
-    end
 
-    def extract_cover(root)
-      metadata = extract_metadata(root)
-      config = @rules['cover'] || {}
-      result = {}
-      (config['fields'] || ['docidentifier', 'edition', 'title_main', 'title_part']).each do |field|
-        result[field.to_sym] = metadata[field.to_sym] if metadata[field.to_sym]
-      end
-      result.empty? ? nil : result
-    end
 
     # ---- Section extraction ----
 
-    def extract_sections(root)
-      sections_config = @rules['sections'] || {}
-      container = sections_config['container'] || 'sections'
-      sections_elem = find_first(root, container)
-      return [] unless sections_elem
 
-      children = []
-      each_direct_child(sections_elem) do |child|
-        next unless map_element(child.name, sections_elem) == 'section'
 
-        children << convert_clause(child)
-      end
-      children
-    end
 
-    def extract_preface(root)
-      preface_elem = find_first(root, selector('preface_container'))
-      return [] unless preface_elem
 
-      result = []
-      each_element(preface_elem) do |child|
-        next if child == preface_elem
-        next unless Array(selector('preface_children')).include?(child.name)
+    # Context-specific title styles (e.g. the XSL rule "level-1
+    # titles inside the preface are centered") live in the flavor's
+    # `title_styles:` map keyed "{context}_{level}" — no core
+    # knowledge of any flavor's heading look.
+    def title_style_for(context, level)
+      configured = @rules.dig('title_styles', "#{context}_#{level}")
+      return :"heading_#{level}" unless configured
 
-        result << convert_clause(child)
-      end
-      result
+      configured.to_sym
     end
 
-    def extract_footnotes(root)
-      container_name = selector('footnote_container')
-      body_name = selector('footnote_body')
-      marker_name = selector('footnote_marker')
-      return [] unless container_name && body_name
-
-      footnotes = []
-      each_element(root) do |elem|
-        next unless elem.name == container_name
-
-        marker = elem.attribute('id')&.value || elem.attribute(marker_name)&.value || ''
-        body_elem = find_first(elem, body_name)
-        body = []
-        if body_elem
-          para_name = selector('paragraph')
-          each_element(body_elem) do |child|
-            next unless child.name == para_name
-
-            body << convert_paragraph(child)
-          end
-        end
-        next if body.empty?
-
-        footnotes << Content::Footnote.new(
-          marker: marker,
-          body: body,
-          id: elem.attribute(selector('id_attribute'))&.value
-        )
-      end
-      footnotes
-    end
-
-    def extract_bibliography(root)
-      biblio_elem = find_first(root, selector('bibliography_container'))
-      return [] unless biblio_elem
-
-      result = []
-      each_element(biblio_elem) do |child|
-        next if child == biblio_elem
-        next unless child.name == selector('bibliography_reference')
-
-        items = []
-        each_child(child, selector('bibliography_item')) { |bi| items << convert_bibitem(bi) }
-        result << Content::Section.new(
-          title: 'Bibliography',
-          level: 1,
-          children: items,
-          style_id: :section_body_1,
-          title_style_id: :heading_1
-        )
-      end
-      result
-    end
 
     # ---- Element converters (driven by rules) ----
 
-    def convert_clause(elem)
+    def convert_clause(elem, context: 'body')
       title, number = extract_heading(elem)
       children = convert_children(elem)
-      level = clause_level(elem)
+      level = clause_level(elem, number: number)
       Content::Section.new(
         title: title, level: level, number: number,
         id: elem.attribute(selector('id_attribute'))&.value, children: children,
         style_id: :"section_body_#{level}",
-        title_style_id: :"heading_#{level}"
+        title_style_id: title_style_for(context, level)
       )
     end
 
-    def clause_level(elem)
-      heading_name = selector('heading')
-      depth_attr = selector('heading_depth_attribute')
-      fmt_title = elem.elements.first { |e| e.name == heading_name }
-      depth = fmt_title&.attribute(depth_attr)&.value.to_i
-      [depth, 1].max
-    end
+
+    # Maps content_type (declared in rules.element_mapping) to a
+    # Each builder accepts a child element and returns one or more
+    # Content nodes. The dispatch_converter helper wraps single
+    # returns in an Array so the caller can always concat.
+    private
 
     def convert_children(parent)
       children = []
@@ -230,33 +179,55 @@ module Arrolio
         type = mapping[child.name]&.dig('content_type')
         next if type.nil?
 
-        case type
-        when 'section'
-          children << convert_clause(child)
-        when 'paragraph'
-          children << convert_paragraph(child)
-        when 'table'
-          children << convert_table(child)
-        when 'figure'
-          children.concat(convert_figure(child))
-        when 'list'
-          children << convert_list(child, kind: mapping[child.name]['kind']&.to_sym || :bullet)
-        when 'term'
-          children.concat(convert_term(child))
-        when 'note'
-          children.concat(convert_note(child))
-        when 'preformatted'
-          children << Content::Preformatted.new(
-            text_of(child).split("\n", -1),
-            style_id: :preformatted
-          )
-        end
+        converter = CONVERTER_REGISTRY[type]
+        next unless converter
+
+        children.concat(dispatch_converter(converter, child, mapping[child.name]))
+        next unless type == 'paragraph'
+
+        children.concat(extract_embedded_blocks(child))
       end
       children
     end
 
+    def extract_embedded_blocks(elem)
+      extractor = Arrolio::EmbeddedBlockExtractor.new(@rules, CONVERTER_REGISTRY)
+      extractor.extract(elem) do |converter, descendant, mapping_entry|
+        dispatch_converter(converter, descendant, mapping_entry)
+      end
+    end
+
+    # Routes to a converter. 'list' needs the kind argument pulled
+    # from the mapping entry; all others take just the child.
+    def dispatch_converter(converter, child, mapping_entry)
+      if converter == :convert_list
+        result = send(converter, child, kind: mapping_entry['kind']&.to_sym || :bullet)
+        result.is_a?(Array) ? result : [result]
+      elsif converter == :convert_preformatted
+        [send(converter, child)]
+      else
+        result = send(converter, child)
+        result.is_a?(Array) ? result : [result]
+      end
+    end
+
+    def convert_preformatted(child)
+      Content::Preformatted.new(
+        text_of(child).split("\n", -1),
+        style_id: :preformatted
+      )
+    end
+
+    def convert_section(child)
+      convert_clause(child)
+    end
+
+    # A paragraph's <fn> reference contributes only its marker; the
+    # body renders in the page's footnote zone (engine collects
+    # FootnoteMarkerFlowables per page). Inlining the body into the
+    # runs doubles the text and displaces the flow.
     def convert_paragraph(elem)
-      runs = collect_inline_runs(elem)
+      runs = collect_inline_runs(elem, footnote_markers: true)
       refs = extract_footnote_refs(elem)
       Content::Paragraph.new(runs, style_id: paragraph_style(elem),
                                    id: elem.attribute(selector('id_attribute'))&.value,
@@ -279,83 +250,86 @@ module Arrolio
       refs
     end
 
-    def convert_table(elem)
-      header = convert_table_rows(find_first(elem, selector('table_header')), true)
-      body = convert_table_rows(find_first(elem, selector('table_body')), false)
-      Content::Table.new(header: header, body: body, style_id: :table,
-                         id: elem.attribute(selector('id_attribute'))&.value)
-    end
+    def convert_figure(elem)
+      image = extract_figure_image(elem)
+      name = find_first(elem, selector('figure_caption')) ||
+             find_first(elem, selector('figure_caption_fallback'))
+      caption = nil
+      if name
+        runs = collect_inline_runs(name)
+        caption = Content::Paragraph.new(runs, style_id: :figure_caption) unless runs.empty?
+      end
+      return [] if image.nil? && caption.nil?
 
-    def convert_table_rows(parent, is_header)
-      return [] unless parent
+      [Content::FigureGroup.new(image: image, caption: caption, id: elem.attribute(selector('id_attribute'))&.value)]
+    end
 
-      rows = []
-      row_name = selector('table_row')
-      cell_names = Array(selector('table_cell'))
-      each_child(parent, row_name) do |tr|
-        cells = []
-        each_element(tr) do |cell|
-          next unless cell_names.include?(cell.name)
+    def extract_figure_image(elem)
+      image_name = selector('figure_image')
+      image_elem = find_direct_child(elem, image_name)
 
-          runs = collect_inline_runs(cell)
-          cells << Content::Table::Cell.new(
-            [Content::Paragraph.new(runs, style_id: is_header ? :table_header_cell : :table_cell)],
-            colspan: (cell.attribute('colspan')&.value || 1).to_i,
-            rowspan: (cell.attribute('rowspan')&.value || 1).to_i,
-            style_id: is_header ? :table_header_cell : :table_cell
+      if image_elem
+        svg_elem = nil
+        image_elem.each_recursive { |e| svg_elem = e if e.name == 'svg' && svg_elem.nil? }
+        if svg_elem
+          svg_xml = serialize_element_to_xml(svg_elem)
+          width, height = svg_viewbox_dimensions(svg_elem)
+          return Content::Image.new(
+            "inline-svg:#{svg_xml}",
+            width: width,
+            height: height,
+            id: image_elem.attribute(selector('id_attribute'))&.value
           )
         end
-        rows << Content::Table::Row.new(cells)
+
+        src = image_elem.attribute(selector('image_src_attribute'))&.value
+        return nil if src.nil? || src.empty?
+
+        return Content::Image.new(
+          src,
+          alt: image_elem.attribute(selector('image_alt_attribute'))&.value,
+          id: image_elem.attribute(selector('id_attribute'))&.value
+        )
       end
-      rows
+
+      svg_elem = nil
+      elem.each_recursive { |e| svg_elem = e if e.name == 'svg' && svg_elem.nil? }
+      return nil unless svg_elem
+
+      svg_xml = serialize_element_to_xml(svg_elem)
+      width, height = svg_viewbox_dimensions(svg_elem)
+      Content::Image.new(
+        "inline-svg:#{svg_xml}",
+        width: width,
+        height: height,
+        id: elem.attribute(selector('id_attribute'))&.value
+      )
     end
 
-    def convert_list(elem, kind:)
-      items = []
-      item_name = selector('list_item')
-      label_name = selector('list_item_label')
-      para_name = selector('paragraph')
-      each_child(elem, item_name) do |li|
-        marker = nil
-        label_elem = find_first(li, label_name)
-        marker = text_of(label_elem) if label_elem
+    def svg_viewbox_dimensions(svg_elem)
+      viewbox = svg_elem.attribute('viewBox')&.value
+      return [nil, nil] unless viewbox
 
-        paras = []
-        each_element(li) do |child|
-          next unless child.name == para_name
+      parts = viewbox.split(/\s+/)
+      return [nil, nil] unless parts.length == 4
 
-          paras << convert_paragraph(child)
-        end
-        content = paras.empty? ? [Content::Paragraph.new(collect_inline_runs(li))] : paras
-        items << Content::List::Item.new(content, marker: marker)
-      end
-      Content::List.new(items, kind: kind, style_id: kind == :ordered ? :list_ordered : :list_bullet)
+      # SVG user units are CSS pixels (96dpi); layout works in PDF
+      # points (72dpi). FOP applies this factor to viewport-less
+      # SVGs, so figures come out a third smaller than their raw
+      # viewBox numbers.
+      width = parts[2].to_f * (72.0 / 96.0)
+      height = parts[3].to_f * (72.0 / 96.0)
+      width.positive? ? [width, height] : [nil, nil]
     end
 
-    def convert_figure(elem)
-      image_name = selector('figure_image')
-      src_attr = selector('image_src_attribute')
-      alt_attr = selector('image_alt_attribute')
-      image_elem = find_direct_child(elem, image_name)
-      image = nil
-      if image_elem
-        src = image_elem.attribute(src_attr)&.value
-        if src && !src.empty?
-          image = Content::Image.new(src,
-                                     alt: image_elem.attribute(alt_attr)&.value,
-                                     id: image_elem.attribute(selector('id_attribute'))&.value)
-        end
-      end
-      name = find_first(elem, selector('figure_caption')) ||
-             find_first(elem, selector('figure_caption_fallback'))
-      caption = nil
-      if name
-        runs = collect_inline_runs(name)
-        caption = Content::Paragraph.new(runs, style_id: :figure_caption) unless runs.empty?
-      end
-      return [] if image.nil? && caption.nil?
+    def nested_in_term?(node, boundary)
+      ancestor = node.parent
+      while ancestor && ancestor != boundary
+        return true if ancestor.name == 'term'
 
-      [Content::FigureGroup.new(image: image, caption: caption, id: elem.attribute(selector('id_attribute'))&.value)]
+        ancestor = ancestor.parent
+      end
+      false
     end
 
     def convert_term(elem)
@@ -375,10 +349,15 @@ module Arrolio
       definition_elem = find_first(elem, selector('term_definition'))
       if definition_elem
         para_name = selector('paragraph')
+        # Only paragraphs of THIS term: nested <term> entries are
+        # converted separately, and their paragraphs must not be
+        # swallowed into the parent definition.
         REXML::XPath.each(definition_elem, ".//#{para_name}") do |p|
           next unless p.is_a?(REXML::Element)
+          next if p.parent != definition_elem && nested_in_term?(p, definition_elem)
 
           definition << convert_paragraph(p)
+          extract_embedded_blocks(p).each { |block| definition << block }
         end
       end
 
@@ -389,27 +368,100 @@ module Arrolio
         source = Content::Paragraph.new(runs, style_id: :bibitem) unless runs.empty?
       end
 
+      # A termnote belongs to its entry (rendered inside it, with
+      # the entry's note styling) — not as a sibling block.
+      nested = []
+      each_element(elem) do |child|
+        next unless child.parent == elem
+
+        case child.name
+        when 'termnote'
+          definition.concat(convert_note(child))
+        when elem.name
+          # Nested terms (e.g. 3.1.3.1-3.1.3.4 under "load cell")
+          # are entries in their own right; dropping them loses whole
+          # definitions.
+          nested.concat(convert_term(child))
+        end
+      end
+
       return [] if number.nil? && preferred.nil? && definition.empty? && source.nil?
 
-      [Content::TermEntry.new(number: number, preferred: preferred,
-                              definition: definition, source: source,
-                              id: elem.attribute(selector('id_attribute'))&.value)]
+      entry = Content::TermEntry.new(number: number, preferred: preferred,
+                                     definition: definition, source: source,
+                                     id: elem.attribute(selector('id_attribute'))&.value)
+      [entry] + nested
     end
 
+    # A note's body is paragraphs PLUS embedded lists (a termnote
+    # may end in a bullet list of capabilities, for example) - the
+    # list elements are siblings of the paragraphs, not children.
     def convert_note(elem)
       label_elem = find_first(elem, selector('note_label'))
       label = label_elem ? text_of(label_elem).strip : ''
 
+      para_name = selector('paragraph')
+      body = []
+      each_element(elem) do |child|
+        case child.name
+        when para_name
+          body << convert_paragraph(child)
+          extract_embedded_blocks(child).each { |block| body << block }
+        when 'ul', 'ol'
+          dispatch_list(child, body)
+        end
+      end
+      return [] if body.empty?
+
+      [Content::Note.new(label: label, body: body, id: elem.attribute(selector('id_attribute'))&.value)]
+    end
+
+    def dispatch_list(elem, body)
+      mapping_entry = (@rules['element_mapping'] || {})[elem.name]
+      kind = mapping_entry&.fetch('kind', nil)&.to_sym || :bullet
+      converted = convert_list(elem, kind: kind)
+      body.concat(converted.is_a?(Array) ? converted : [converted])
+    end
+
+    # An example renders its label as a block heading ("Example:"),
+    # so the label is the localized element name only — the autonum
+    # in fmt-name belongs to cross-references, not the display.
+    def convert_example(elem)
+      label_elem = find_first(elem, selector('note_label'))
+      label = element_name_text(label_elem) || (label_elem ? text_of(label_elem).strip : '')
+
       para_name = selector('paragraph')
       body = []
       each_element(elem) do |child|
         next unless child.name == para_name
 
-        body << convert_paragraph(child)
+        para = convert_paragraph(child)
+        # Example bodies take the example style (leading, indents) —
+        # the source paragraphs carry the generic inline style.
+        body << Content::Paragraph.new(para.inline_runs, style_id: :example,
+                                                         id: para.id,
+                                                         footnote_refs: para.footnote_refs)
       end
       return [] if body.empty?
 
-      [Content::Note.new(label: label, body: body, id: elem.attribute(selector('id_attribute'))&.value)]
+      [Content::Example.new(label: label, body: body, id: elem.attribute(selector('id_attribute'))&.value)]
+    end
+
+    def element_name_text(label_elem)
+      return nil unless label_elem
+
+      name_class = selector('element_name')
+      return nil unless name_class
+
+      span = nil
+      label_elem.each_recursive do |node|
+        next unless node.is_a?(REXML::Element) && node.name == selector('span') &&
+                    node.attribute('class')&.value == name_class
+
+        span = node
+        break
+      end
+      span ? text_of(span).strip : nil
     end
 
     def convert_bibitem(bi)
@@ -436,47 +488,20 @@ module Arrolio
 
     # ---- Inline run collection (driven by rules) ----
 
-    def collect_inline_runs(elem, default_style: :inline)
-      runs = []
-      stem_name = selector('stem')
-      stem_formatted_name = selector('stem_formatted')
-      math_name = selector('math')
-      tab_name = selector('tab_inline')
-      br_name = selector('break_inline')
-      skip_metadata = @rules['skip_metadata_elements'].to_a
-      block_level = @rules['block_level_elements'].to_a
-
-      walker = lambda do |node, style|
-        case node
-        when REXML::Text
-          text = normalize_text(node.value)
-          next if text.nil? || text.empty?
-
-          runs << Content::InlineRun.new(text, style_id: style)
-        when REXML::Element
-          new_style = resolve_inline_style(node, style)
-          case node.name
-          when tab_name
-            runs << Content::InlineRun.new("\t", style_id: style)
-          when br_name
-            runs << Content::InlineRun.new("\n", style_id: style)
-          when stem_name
-            unless sibling_exists?(node.parent, stem_formatted_name)
-              walk_stem(node, style, runs, stem_formatted_name, math_name)
-            end
-          when stem_formatted_name
-            walk_math(node, style, runs)
-          when *skip_metadata
-            next
-          when *block_level
-            next
-          else
-            node.children.each { |c| walker.call(c, new_style) }
-          end
-        end
+
+
+    def baseline_for_style(rules, element, current_baseline, current_scale)
+      mapping = rules[element.name]
+      return [current_baseline, current_scale] unless mapping
+
+      case mapping.to_sym
+      when :subscript
+        [Content::InlineRun::BASELINE_SUB, (current_scale * 0.7).round(4)]
+      when :superscript
+        [Content::InlineRun::BASELINE_SUP, (current_scale * 0.7).round(4)]
+      else
+        [current_baseline, current_scale]
       end
-      elem.children.each { |c| walker.call(c, default_style) }
-      runs
     end
 
     def resolve_inline_style(elem, current)
@@ -493,96 +518,17 @@ module Arrolio
       current
     end
 
-    def walk_stem(stem_elem, style, runs, formatted_name, math_name)
-      target = find_first(stem_elem, formatted_name) || find_first(stem_elem, math_name)
-      walk_math(target, style, runs) if target
-    end
-
-    def walk_math(elem, style, runs)
-      return unless elem
 
-      elem.each_recursive do |child|
-        next unless child.is_a?(REXML::Text)
 
-        text = normalize_text(child.value)
-        next if text.nil? || text.empty?
-
-        runs << Content::InlineRun.new(text, style_id: style)
-      end
-    end
 
     # ---- Heading extraction ----
 
-    def extract_heading(clause)
-      heading_config = @rules['heading'] || {}
-      source = heading_config['source'] || selector('heading')
-      heading_elem = find_first(clause, source)
-      if heading_elem
-        extract_from_heading(heading_elem)
-      else
-        title = find_first(clause, selector('fallback_title'))
-        [title ? text_of(title) : nil, nil]
-      end
-    end
 
-    def extract_from_heading(heading_elem)
-      parts = []
-      number_parts = []
-      title_parts = []
-      autonum_class = selector('autonum_class')
 
-      walk_heading_text(heading_elem) do |text, parent|
-        parts << text
-        element_attr = parent&.attribute('element')&.value
-        if element_attr == 'autonum' || autonum_class_parent?(parent, autonum_class)
-          number_parts << text
-        elsif element_attr == 'title'
-          title_parts << text
-        end
-      end
-
-      number = number_parts.join.strip
-      number = nil if number.empty?
-
-      title = if title_parts.any?
-                title_parts.join.strip
-              elsif parts.include?("\t")
-                parts.join.split("\t", 2).last&.strip
-              else
-                all_text = parts.join.strip
-                all_text.empty? ? nil : all_text
-              end
-      title = nil if title.nil? || title.empty?
-      [title, number]
-    end
-
-    def walk_heading_text(element, &block)
-      element.children.each do |child|
-        case child
-        when REXML::Text
-          yield(child.value, child.parent)
-        when REXML::Element
-          walk_heading_text(child, &block)
-        end
-      end
-    end
-
-    def autonum_class_parent?(node, autonum_class)
-      parent = node.parent
-      parent && parent.attribute('class')&.value == autonum_class
-    end
 
     # ---- Text helpers ----
 
-    def normalize_text(raw)
-      return raw unless raw.is_a?(String)
-      return raw unless raw.include?("\n")
 
-      stripped = raw.strip
-      return raw.match?(/ /) ? ' ' : nil if stripped.empty?
-
-      stripped.gsub(/\s+/, ' ')
-    end
 
     def text_of(elem)
       return '' unless elem