arrolio 0.1.0 → 0.1.2

data/lib/arrolio/font/embedder.rb

@@ -87,16 +87,35 @@ module Arrolio
           sf = Fontisan::FontLoader.load(path)
           cm = sf.table('cmap').unicode_mappings
           @subset_cp_to_gid = cm.transform_keys(&:to_i)
-          @subset_gid_to_cp = @subset_cp_to_gid.invert
+          @subset_gid_to_cp = invert_prefer_ascii(@subset_cp_to_gid)
         end
       rescue StandardError => e
         Arrolio::Logger.warn "subset cmap extract failed: #{e.message[0,80]}"
         @subset_cp_to_gid = @unicode_to_gid
-        @subset_gid_to_cp = @unicode_to_gid.invert
+        @subset_gid_to_cp = invert_prefer_ascii(@unicode_to_gid)
+      end
+
+      # Build GID -> codepoint map, preferring ASCII codepoints when
+      # multiple codepoints share the same GID. Fonts commonly have
+      # both U+0020 (SPACE) and U+00A0 (NO-BREAK SPACE) mapped to
+      # the same glyph; without preference, Hash#invert would keep
+      # U+00A0, breaking text extraction (pdftotext reads no-break
+      # spaces as solid characters, not word separators).
+      def invert_prefer_ascii(cp_to_gid)
+        result = {}
+        cp_to_gid.each do |cp, gid|
+          existing = result[gid]
+          if existing.nil?
+            result[gid] = cp
+          elsif cp < 0x80 && existing >= 0x80
+            result[gid] = cp
+          end
+        end
+        result
       end
 
       def build_tounicode_stream
-        gid_to_cp = @subset_gid_to_cp || @unicode_to_gid.invert
+        gid_to_cp = @subset_gid_to_cp || invert_prefer_ascii(@unicode_to_gid)
         lines = []
         lines << '/CIDInit /ProcSet findresource begin'
         lines << '12 dict begin'

data/lib/arrolio/font_scanner.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'fontisan'
+
+module Arrolio
+  # Scans font directories for TTF files and builds an index of
+  # family-name → file-path mappings using Fontisan to read each
+  # font's internal name tables. Used by ConfigDrivenPipeline to
+  # resolve font family names referenced by layout styles to actual
+  # TTF files on disk.
+  class FontScanner
+    FONT_DIRECTORIES = [
+      File.expand_path('~/.fontist/fonts'),
+      '/Library/Fonts',
+      '/System/Library/Fonts',
+      File.expand_path('~/Library/Fonts')
+    ].freeze
+
+    attr_reader :index
+
+    def initialize(directories = FONT_DIRECTORIES)
+      @directories = directories
+      @index = nil
+    end
+
+    def resolve(font_name)
+      build_index unless @index
+      @index[font_name.to_s]
+    end
+
+    def build_index
+      @index = {}
+      @directories.each do |dir|
+        scan_directory(dir)
+      end
+      @index
+    end
+
+    private
+
+    def scan_directory(dir)
+      Dir.glob(File.join(dir, '**', '*.ttf')).each do |path|
+        add_to_index(path)
+      end
+      Dir.glob(File.join(dir, '**', '*.TTF')).each do |path|
+        add_to_index(path)
+      end
+    end
+
+    def add_to_index(path)
+      info = read_font_info(path)
+      return unless info
+
+      info[:names].each do |name|
+        @index[name] ||= path
+      end
+    end
+
+    def read_font_info(path)
+      font = Fontisan::FontLoader.load(path)
+      name_table = font.table('name')
+      return nil unless name_table
+
+      storage = name_table.string_storage
+      names = extract_names(name_table, storage)
+      weight = extract_weight(font)
+      style_suffix = extract_style_suffix(font)
+      family = name_id(name_table, storage, 1)
+
+      names.map { |n| @index[n] ||= path }
+      if family && style_suffix
+        @index["#{family} #{style_suffix}"] ||= path
+      end
+      @index[family] ||= path if family
+      return nil unless family
+
+      { names: names, family: family, weight: weight }
+    rescue StandardError
+      nil
+    end
+
+    def extract_style_suffix(font)
+      os2 = font.table('OS/2')
+      return nil unless os2
+
+      flags = os2.fs_selection.to_i
+      weight = os2.us_weight_class.to_i
+      parts = []
+      parts << 'Bold' if flags.anybits?(32) || weight >= 700
+      parts << 'Italic' if flags.anybits?(1)
+      parts.empty? ? nil : parts.join(' ')
+    rescue StandardError
+      nil
+    end
+
+    def extract_names(name_table, storage)
+      names = []
+      [1, 4, 6, 16].each do |name_id|
+        name = name_id(name_table, storage, name_id)
+        names << name if name && !name.empty?
+      end
+      # Register family + variant suffix for bold/italic resolution
+      family = name_id(name_table, storage, 1)
+      subfamily = name_id(name_table, storage, 2)
+      if family && subfamily
+        names << "#{family} #{subfamily}" unless subfamily == 'Regular'
+        names << family if subfamily == 'Regular'
+      end
+      names.uniq
+    end
+
+    def extract_weight(font)
+      os2 = font.table('OS/2')
+      return nil unless os2
+
+      os2.weight_class rescue nil
+    end
+
+    def name_id(name_table, storage, id)
+      record = name_table.name_records.find do |r|
+        r.name_id == id && r.platform_id == 3
+      end
+      return nil unless record
+
+      storage.byteslice(record.string_offset, record.string_length)
+             .force_encoding('UTF-16BE')
+             .encode('UTF-8', invalid: :replace, undef: :replace)
+             .strip
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/arrolio/generic_adapter/document_extraction.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Arrolio
+  class GenericAdapter
+    # Extracted conversion seam (TODO 56): one module per concern,
+    # included into the adapter. The class keeps dispatch and glue.
+    module DocumentExtraction
+      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_title_block(root)
+        sections_config = @rules['sections'] || {}
+        container = sections_config['container'] || 'sections'
+        sections_elem = find_first(root, container)
+        return nil unless sections_elem
+
+        para_name = selector('paragraph')
+        each_direct_child(sections_elem) do |child|
+          next unless child.name == para_name
+
+          cls = child.attribute('class')&.value
+          title_style = (@rules['paragraph_styles'] || {})[cls]
+          next unless title_style
+
+          return Content::Paragraph.new(
+            title_block_runs(root),
+            style_id: title_style.to_sym,
+            id: child.attribute(selector('id_attribute'))&.value
+          )
+        end
+        nil
+      end
+
+      def title_block_runs(root)
+        metadata = extract_metadata(root)
+        part = metadata[:part_number].to_s
+        title_part = metadata[:title_part].to_s
+        locality = @rules.dig('i18n', 'locality_part').to_s
+        locality = 'Part' if locality.empty?
+        text = if part.empty? && title_part.empty?
+                 ''
+               elsif part.empty?
+                 title_part
+               else
+                 "#{locality} #{part} - #{title_part}".strip
+               end
+        [Content::InlineRun.new(text, style_id: :doc_title)]
+      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)
+
+          result << convert_clause(child, context: :preface)
+        end
+        result
+      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')) do |bi|
+            items.concat(convert_bibitem(bi))
+          end
+          result << Content::Section.new(
+            title: 'Bibliography',
+            level: 1,
+            children: items,
+            style_id: :section_body_1,
+            title_style_id: title_style_for('bibliography', 1)
+          )
+        end
+        result
+      end
+    end
+  end
+end

data/lib/arrolio/generic_adapter/footnote_extraction.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Arrolio
+  class GenericAdapter
+    # Footnote extraction, split from the adapter body (TODO 56
+    # MECE split). Included as a module so the extraction logic
+    # stays with its selectors while the adapter class stays lean.
+    module FootnoteExtraction
+      # Footnotes come in two shapes: the formatted container
+      # (fmt-footnote-container + fmt-fn-body) and the raw marker
+      # element (<fn reference="a">) whose body is its own paragraphs.
+      # Both register in Document#footnotes, keyed by id; the raw form
+      # is what body text and table cells reference.
+      def extract_footnotes(root)
+        container_name = selector('footnote_container')
+        body_name = selector('footnote_body')
+        marker_name = selector('footnote_marker')
+        return [] unless marker_name || (container_name && body_name)
+
+        footnotes = []
+        ids = []
+        # Recursive: footnote containers and raw <fn> markers live at
+        # arbitrary depths inside clauses, tables, and terms.
+        root.each_recursive do |elem|
+          if container_name && 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?
+
+          id = elem.attribute(selector('id_attribute'))&.value
+          next if id && ids.include?(id)
+
+          ids << id if id
+          footnotes << Content::Footnote.new(
+            marker: marker,
+            body: body,
+            id: id
+          )
+          elsif marker_name && elem.name == marker_name
+            id = elem.attribute('id')&.value ||
+                 elem.attribute(selector('id_attribute'))&.value
+            next if id && ids.include?(id)
+
+            marker = elem.attribute('reference')&.value || id || ''
+            body = footnote_body_paragraphs(elem)
+            next if body.empty?
+
+            ids << id if id
+            footnotes << Content::Footnote.new(
+              marker: marker,
+              body: body,
+              id: id
+            )
+          end
+        end
+        footnotes
+      end
+
+      def footnote_body_paragraphs(elem)
+        para_name = selector('paragraph')
+        paragraphs = []
+        each_element(elem) do |child|
+          next unless child.name == para_name
+
+          paragraphs << convert_paragraph(child)
+        end
+        paragraphs
+      end
+    end
+  end
+end

data/lib/arrolio/generic_adapter/heading_extraction.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Arrolio
+  class GenericAdapter
+    # Extracted conversion seam (TODO 56): one module per concern,
+    # included into the adapter. The class keeps dispatch and glue.
+    module HeadingExtraction
+      # The level derives from the autonumber's dotted depth ("5.1.1"
+      # → 3, "A.1" → 2) when present — the semantic truth — falling
+      # back to the fmt-title depth attribute. Titles without either
+      # stay level 1. Relying on the attribute alone mis-leveled most
+      # sections (3.x, 5.1.x) because their fmt-title carries no depth.
+      def clause_level(elem, number: nil)
+        dotted = number.to_s.split('.').length
+        return dotted if dotted > 1 && number.to_s.match?(/\A[\dA-Z]/)
+
+        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
+
+      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 = []
+        non_number_parts = []
+        autonum_class = selector('autonum_class')
+        autonum_delim_class = selector('autonum_delim_class') || 'fmt-autonum-delim'
+        caption_label_class = selector('caption_label_class') || 'fmt-caption-label'
+
+        walk_heading_text(heading_elem) do |text, parent|
+          parts << text
+          element_attr = parent&.attribute('element')&.value
+          parent_class = parent&.attribute('class')&.value
+          if element_attr == 'autonum' ||
+             parent_class == autonum_class ||
+             parent_class == autonum_delim_class ||
+             parent_class == caption_label_class
+            number_parts << text
+          elsif element_attr == 'title'
+            title_parts << text
+            non_number_parts << text
+          else
+            non_number_parts << text
+          end
+        end
+
+        number = number_parts.map(&:strip).reject(&:empty?).join
+        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
+                  non_number_parts.join.strip
+                end
+        title = nil if title.nil? || title.empty?
+        [title, number]
+      end
+
+      def walk_heading_text(element, &block)
+        element.children.each do |child|
+          next if child.is_a?(REXML::Element) &&
+                  (XREF_ELEMENTS.include?(child.name) ||
+                   child.attribute('element')&.value == 'xref')
+
+          case child
+          when REXML::Text
+            yield(child.value, child.parent)
+          when REXML::Element
+            walk_heading_text(child, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/generic_adapter/inline_run_collection.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Arrolio
+  class GenericAdapter
+    # Extracted conversion seam (TODO 56): one module per concern,
+    # included into the adapter. The class keeps dispatch and glue.
+    module InlineRunCollection
+    UNICODE_SPACES = Regexp.new("[\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000\uFEFF]")
+    def collect_inline_runs(elem, default_style: :inline, exclude: nil,
+                            footnote_markers: false)
+      runs = []
+      stem_name = selector('stem')
+      fn_name = footnote_markers ? selector('footnote_marker') : nil
+      stem_formatted_name = selector('stem_formatted')
+      math_name = selector('math')
+      tab_name = selector('tab_inline')
+      br_name = selector('break_inline')
+      xref_name = selector('biblio_formattedref') ? 'fmt-xref' : nil
+      skip_metadata = @rules['skip_metadata_elements'].to_a
+      block_level = @rules['block_level_elements'].to_a
+      inline_styles = @rules['inline_styles'] || {}
+
+      walker = lambda do |node, style, baseline: Content::InlineRun::BASELINE_NORMAL, scale: 1.0, in_xref: false|
+        case node
+        when REXML::Text
+          raw = normalize_text(node.value)
+          next if raw.nil? || raw.empty?
+
+          text = in_xref ? format_locality_text(raw) : raw
+          runs << Content::InlineRun.new(text, style_id: style,
+                                               baseline_shift: baseline,
+                                               font_size_scale: scale)
+        when REXML::Element
+          next if exclude && node.name == exclude
+
+          if fn_name && node.name == fn_name
+            marker = node.attribute('reference')&.value ||
+                     node.attribute('id')&.value
+            unless marker.nil? || marker.empty?
+              runs << Content::InlineRun.new(
+                marker, style_id: style,
+                        baseline_shift: Content::InlineRun::BASELINE_SUP,
+                        font_size_scale: 0.7
+              )
+            end
+            next
+          end
+
+          new_style = resolve_inline_style(node, style)
+          sub_baseline, sub_scale = baseline_for_style(inline_styles, node,
+                                                       baseline, scale)
+          child_in_xref = in_xref || (xref_name && node.name == xref_name)
+          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 do |c|
+ walker.call(c, new_style, baseline: sub_baseline, scale: sub_scale, in_xref: child_in_xref)
+            end
+          end
+        end
+      end
+      elem.children.each { |c| walker.call(c, default_style) }
+      runs
+    end
+
+    def format_locality_text(text)
+      text.gsub(/([a-zA-Z]+)=/, '\\1 ')
+    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
+
+    # Walks a MathML tree emitting InlineRuns with appropriate
+    # baseline_shift + font_size_scale. Delegates the actual MathML
+    # parsing to the plurimath/mml gem via MathML::InlineRunExtractor,
+    # keeping this adapter free of its own MathML grammar.
+    def walk_math(elem, style, runs)
+      return unless elem
+
+      math_name = selector('math')
+      math_elem = if elem.name == math_name
+        elem
+      else
+        found = nil
+        elem.each_recursive { |e| found = e if e.name == math_name && found.nil? }
+        found
+      end
+      return unless math_elem
+
+      math_xml = serialize_element_to_xml(math_elem)
+      extracted = ::Arrolio::MathML::InlineRunExtractor.extract_from_xml(math_xml,
+                                                                         base_style: style)
+      runs.concat(extracted)
+    end
+
+    def serialize_element_to_xml(elem)
+      io = StringIO.new(+'')
+      REXML::Formatters::Default.new.write(elem, io)
+      io.string
+    end
+
+    # Newline-bearing text nodes keep ONE space at each boundary:
+    # 'where\n<stem>' must render 'where Y' — stripping the
+    # trailing whitespace glued words to the following element and
+    # made long formula runs unbreakable (clipped at the page
+    # edge).
+    def normalize_text(raw)
+      return raw unless raw.is_a?(String)
+      cleaned = raw.gsub(UNICODE_SPACES, ' ')
+      return cleaned unless cleaned.include?("\n")
+
+      stripped = cleaned.strip
+      return cleaned.match?(/\s/) ? ' ' : nil if stripped.empty?
+
+      lead = cleaned.match?(/\A\s/) ? ' ' : ''
+      trail = cleaned.match?(/\s\z/) ? ' ' : ''
+      lead + stripped.gsub(/\s+/, ' ') + trail
+    end
+    end
+  end
+end

data/lib/arrolio/generic_adapter/list_conversion.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Arrolio
+  class GenericAdapter
+    # Extracted conversion seam (TODO 56): one module per concern,
+    # included into the adapter. The class keeps dispatch and glue.
+    module ListConversion
+      def convert_list(elem, kind:)
+        return convert_definition_list(elem) if elem.name == 'dl'
+
+        items = []
+        item_name = selector('list_item')
+        label_name = selector('list_item_label')
+        para_name = selector('paragraph')
+        list_mapping = (@rules['element_mapping'] || {}).select do |_, v|
+          v['content_type'] == 'list'
+        end
+        each_child(elem, item_name) do |li|
+          # Ordered lists carry their autonum in the label element;
+          # unordered lists don't number (the label text is a
+          # placeholder) — they render the flavor's bullet instead.
+          marker = nil
+          if kind != :bullet
+            label_elem = find_first(li, label_name)
+            marker = text_of(label_elem) if label_elem
+          end
+
+          content = []
+          each_element(li) do |child|
+            next if child.parent && child.parent != li
+
+            if child.name == para_name
+              content << convert_paragraph(child)
+            elsif list_mapping.key?(child.name)
+              nested_kind = list_mapping[child.name]['kind']&.to_sym || :bullet
+              content << convert_list(child, kind: nested_kind)
+            end
+          end
+          content = [Content::Paragraph.new(collect_inline_runs(li))] if content.empty?
+          items << Content::List::Item.new(content, marker: marker)
+        end
+        Content::List.new(items, kind: kind, style_id: kind == :ordered ? :list_ordered : :list_bullet)
+      end
+
+      def convert_definition_list(elem)
+        items = []
+        para_name = selector('paragraph')
+        current_marker = nil
+
+        each_direct_child(elem) do |child|
+          case child.name
+          when 'dt'
+            current_marker = text_of(child).strip
+          when 'dd'
+            content = []
+            each_element(child) do |c|
+              next unless c.name == para_name && c.parent == child
+              content << convert_paragraph(c)
+            end
+            content = [Content::Paragraph.new(collect_inline_runs(child))] if content.empty?
+            items << Content::List::Item.new(content, marker: current_marker)
+            current_marker = nil
+          end
+        end
+
+        Content::List.new(items, kind: :definition, style_id: :list_bullet)
+      end
+    end
+  end
+end