arrolio 0.1.0 → 0.1.2

data/lib/arrolio/math_ml/inline_run_extractor.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require 'mml'
+
+module Arrolio
+  module MathML
+    # Walks a parsed Mml tree (from +Mml.parse(xml_string, version: 3)+)
+    # and emits an Array of +Content::InlineRun+ values, applying
+    # +baseline_shift+ and +font_size_scale+ to match the math
+    # layout semantics of each MathML element.
+    #
+    # The extractor relies on the canonical Mml gem (plurimath/mml)
+    # for parsing, keeping Arrolio free of its own MathML grammar.
+    # MathML presentation elements map as follows:
+    #
+    #   <mi>                  → italic math run (:math_identifier)
+    #   <mn>, <mo>, <mtext>   → regular math run (parent style)
+    #   <ms>                  → quoted string run (parent style)
+    #   <msub>                → base + subscript run
+    #   <msup>                → base + superscript run
+    #   <msubsup>             → base + sub + sup
+    #   <munder>/<mover>      → rendered as sub/sup for visual fidelity
+    #   <mfrac>               → numerator + '/' + denominator (inline)
+    #   <mrow>, <mstyle>      → transparent group, recurse children
+    #
+    # Anything else recurses transparently.
+    class InlineRunExtractor
+
+      # Each entry is [value_attribute, child_collection_attribute, kind]
+      # - value_attribute: node method returning the text content (or nil)
+      # - child_collection_attribute: node method returning child
+      #   elements of that type (Array)
+      # - kind: :text | :identifier | :transparent | :subscript_container
+      #         | :superscript_container | :fraction | :ignored
+      ELEMENT_HANDLERS = {
+        'Mml::V3::Mi' => [:value, :mi_value, :identifier],
+        'Mml::V3::Mn' => [:value, :mn_value, :text],
+        'Mml::V3::Mo' => [:value, :mo_value, :text],
+        'Mml::V3::Mtext' => [:value, :mtext_value, :text],
+        'Mml::V3::Ms' => [:value, :ms_value, :text],
+        'Mml::V3::Mrow' => [nil, nil, :transparent_all],
+        'Mml::V3::Mstyle' => [nil, nil, :transparent_all],
+        'Mml::V3::Msub' => [nil, :msub_value, :subscript_container],
+        'Mml::V3::Msup' => [nil, :msup_value, :superscript_container],
+        'Mml::V3::Msubsup' => [nil, :msubsup_value, :subsup_container],
+        'Mml::V3::Munder' => [nil, :munder_value, :subscript_container],
+        'Mml::V3::Mover' => [nil, :mover_value, :superscript_container],
+        'Mml::V3::Munderover' => [nil, :munderover_value, :subsup_container],
+        'Mml::V3::Mfrac' => [nil, :mfrac_value, :fraction],
+        'Mml::V3::Menclose' => [nil, :menclose_value, :transparent],
+        'Mml::V3::Mphantom' => [nil, :mphantom_value, :transparent],
+        'Mml::V3::Mpadded' => [nil, :mpadded_value, :transparent],
+        'Mml::V3::Merror' => [nil, :merror_value, :transparent],
+        'Mml::V3::Semantics' => [nil, :semantics_value, :transparent],
+        'Mml::V3::Math' => [nil, nil, :transparent_all]
+      }.freeze
+
+      attr_reader :base_style
+
+      def sub_sup_scale = 0.7
+
+      def default_baseline
+        ::Arrolio::Content::InlineRun::BASELINE_NORMAL
+      end
+
+      def sub_baseline
+        ::Arrolio::Content::InlineRun::BASELINE_SUB
+      end
+
+      def sup_baseline
+        ::Arrolio::Content::InlineRun::BASELINE_SUP
+      end
+
+      def initialize(base_style: :math)
+        @base_style = base_style.to_sym
+      end
+
+      def extract(math_node)
+        runs = []
+        walk(math_node, runs, baseline: default_baseline, scale: 1.0,
+                              style_id: base_style)
+        runs
+      end
+
+      # Parse +xml_string+ as MathML and extract the runs. Returns
+      # an empty Array if parsing fails.
+      def self.extract_from_xml(xml_string, base_style: :math)
+        return [] if xml_string.nil? || xml_string.to_s.empty?
+
+        parsed = ::Mml.parse(xml_string.to_s, version: 3)
+        new(base_style: base_style).extract(parsed)
+      rescue StandardError => e
+        Arrolio::Logger.warn "Mml parse failed: #{e.class}: #{e.message[0, 80]}"
+        []
+      end
+
+      private
+
+      def walk(node, runs, baseline:, scale:, style_id:)
+        return unless node
+
+        handler = ELEMENT_HANDLERS[node.class.name]
+        if handler
+          dispatch_handler(node, handler, runs, baseline: baseline,
+                                                scale: scale, style_id: style_id)
+        else
+          # Unknown element: recurse transparently into all child collections.
+          walk_all_children(node, runs, baseline: baseline, scale: scale,
+                                        style_id: style_id)
+        end
+      end
+
+      def dispatch_handler(node, handler, runs, baseline:, scale:, style_id:)
+        _value_attr, child_attr, kind = handler
+        effective_style = kind == :identifier ? :math_identifier : style_id
+        if handler.first
+          emit_text_value(node, runs, baseline: baseline, scale: scale,
+                                      style_id: effective_style)
+        end
+        case kind
+        when :identifier
+          emit_collection_as(node, child_attr, runs, baseline: baseline, scale: scale,
+                                                     style_id: :math_identifier)
+        when :text
+          emit_collection_as(node, child_attr, runs, baseline: baseline, scale: scale,
+                                                     style_id: style_id)
+        when :transparent
+          walk_collection(node, child_attr, runs, baseline: baseline, scale: scale,
+                                                  style_id: style_id)
+        when :transparent_all
+          walk_all_children(node, runs, baseline: baseline, scale: scale,
+                                        style_id: style_id)
+        when :subscript_container
+          process_script_container(node, runs, baseline: baseline, scale: scale,
+                                               style_id: style_id,
+                                               script_baseline: sub_baseline,
+                                               script_position: 1)
+        when :superscript_container
+          process_script_container(node, runs, baseline: baseline, scale: scale,
+                                               style_id: style_id,
+                                               script_baseline: sup_baseline,
+                                               script_position: 1)
+        when :subsup_container
+          process_subsup_container(node, runs, baseline: baseline, scale: scale,
+                                               style_id: style_id)
+        when :fraction
+          process_fraction_container(node, runs, baseline: baseline, scale: scale,
+                                                 style_id: style_id)
+        end
+      end
+
+      def emit_text_value(node, runs, baseline:, scale:, style_id:)
+        value = safe_value(node)
+        return if value.nil? || value.empty?
+
+        runs << ::Arrolio::Content::InlineRun.new(value,
+                                                  style_id: style_id,
+                                                  baseline_shift: baseline,
+                                                  font_size_scale: scale)
+      end
+
+      def emit_collection_as(node, attr, runs, baseline:, scale:, style_id:)
+        children = safe_collection(node, attr)
+        children.each { |c| walk(c, runs, baseline: baseline, scale: scale, style_id: style_id) }
+      end
+
+      def walk_collection(node, attr, runs, baseline:, scale:, style_id:)
+        safe_collection(node, attr).each do |child|
+          walk(child, runs, baseline: baseline, scale: scale, style_id: style_id)
+        end
+      end
+
+      # For <msub>/<msup>: the node IS the container. Its children
+      # are the base (first) and the script (second).
+      def process_script_container(node, runs, baseline:, scale:, style_id:,
+                                   script_baseline:, script_position:)
+        children = all_child_elements(node)
+        base = children.first
+        script = children[script_position]
+        if base
+          walk(base, runs, baseline: baseline, scale: scale,
+                           style_id: style_id)
+        end
+        return unless script
+
+        walk(script, runs, baseline: script_baseline,
+                           scale: reduce_scale(scale),
+                           style_id: style_id)
+      end
+
+      # For <msubsup>: base + sub + sup
+      def process_subsup_container(node, runs, baseline:, scale:, style_id:)
+        children = all_child_elements(node)
+        base = children[0]
+        sub = children[1]
+        sup = children[2]
+        if base
+          walk(base, runs, baseline: baseline, scale: scale,
+                           style_id: style_id)
+        end
+        if sub
+          walk(sub, runs, baseline: sub_baseline,
+                          scale: reduce_scale(scale), style_id: style_id)
+        end
+        return unless sup
+
+        walk(sup, runs, baseline: sup_baseline,
+                        scale: reduce_scale(scale), style_id: style_id)
+      end
+
+      # For <mfrac>: numerator + '/' + denominator, all at reduced scale.
+      def process_fraction_container(node, runs, baseline:, scale:, style_id:)
+        children = all_child_elements(node)
+        numerator = children[0]
+        denominator = children[1]
+        child_scale = reduce_scale(scale)
+        if numerator
+          walk(numerator, runs, baseline: sup_baseline, scale: child_scale,
+                                style_id: style_id)
+        end
+        runs << ::Arrolio::Content::InlineRun.new('/', style_id: style_id,
+                                                       baseline_shift: baseline,
+                                                       font_size_scale: scale)
+        return unless denominator
+
+        walk(denominator, runs, baseline: sub_baseline, scale: child_scale,
+                                style_id: style_id)
+      end
+
+      def walk_all_children(node, runs, baseline:, scale:, style_id:)
+        %i[mi_value mn_value mo_value mtext_value ms_value mrow_value
+           mstyle_value msub_value msup_value msubsup_value mfrac_value
+           menclose_value mphantom_value mpadded_value merror_value
+           mover_value munder_value munderover_value semantics_value
+           msqrt_value mroot_value mtable_value math_value].each do |attr|
+          safe_collection(node, attr).each do |child|
+            walk(child, runs, baseline: baseline, scale: scale, style_id: style_id)
+          end
+        end
+      end
+
+      def all_child_elements(node)
+        %i[mi_value mn_value mo_value mtext_value ms_value mrow_value
+           mstyle_value msub_value msup_value msubsup_value mfrac_value
+           menclose_value mphantom_value mpadded_value merror_value
+           mover_value munder_value munderover_value semantics_value
+           msqrt_value mroot_value mtable_value].flat_map do |attr|
+          safe_collection(node, attr)
+        end
+      end
+
+      def safe_collection(node, attr)
+        return [] unless node.is_a?(::Mml::CommonElements)
+
+        node.public_send(attr)
+      rescue StandardError
+        []
+      end
+
+      def safe_value(node)
+        value = node.value
+        value.is_a?(Array) ? value.join : value.to_s
+      rescue StandardError
+        nil
+      end
+
+      def reduce_scale(current_scale)
+        (current_scale * sub_sup_scale).round(4)
+      end
+    end
+  end
+end

data/lib/arrolio/math_ml.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module MathML
+    autoload :InlineRunExtractor, 'arrolio/math_ml/inline_run_extractor'
+  end
+end

data/lib/arrolio/output/page.rb

@@ -5,13 +5,13 @@ module Arrolio
     class Page
       attr_reader :number, :template_name, :template_role, :page_size,
                   :regions, :static_regions, :header_text, :footer_text,
-                  :header_align, :footer_align, :footnotes
+                  :header_align, :footer_align, :footnotes, :title_text
 
       def initialize(number:, template_name:, page_size:,
                      regions:, static_regions: {}, template_role: :body,
                      header_text: nil, footer_text: nil,
-                     header_align: :right, footer_align: :center,
-                     footnotes: [])
+                     header_align: nil, footer_align: :center,
+                     footnotes: [], title_text: nil)
         @number = number.to_i
         @template_name = template_name.to_sym
         @template_role = template_role.to_sym
@@ -20,9 +20,10 @@ module Arrolio
         @static_regions = static_regions.transform_keys(&:to_sym).freeze
         @header_text = header_text
         @footer_text = footer_text
-        @header_align = header_align.to_sym
+        @header_align = header_align ? header_align.to_sym : :right
         @footer_align = footer_align.to_sym
         @footnotes = Array(footnotes).freeze
+        @title_text = title_text
         freeze
       end
 

data/lib/arrolio/output/placed_box.rb

@@ -17,11 +17,14 @@ module Arrolio
       end
 
       class << self
-        def text(x:, y:, width:, height:, lines:, line_height:, style:, link_dest: nil)
+        def text(x:, y:, width:, height:, lines:, line_height:, style:,
+                 hanging_indent: 0.0, line_heights: nil, link_dest: nil)
           new(x: x, y: y, width: width, height: height, kind: :text,
               data: { lines: Array(lines).freeze,
                       line_height: line_height.to_f,
-                      style: style },
+                      line_heights: line_heights&.map(&:to_f)&.freeze,
+                      style: style,
+                      hanging_indent: hanging_indent.to_f },
               link_dest: link_dest)
         end
 

data/lib/arrolio/renderer/pdf/assets.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    class Pdf
+      # Extracted concern: Pdfrb coupling points kept out of the
+      # emission path.
+      module Assets
+        def register_logo(path)
+          return nil unless path
+
+          @document.images.add(path)
+        rescue StandardError => e
+          Arrolio::Logger.warn "logo load failed: #{e.class}: #{e.message[0, 80]}"
+          nil
+        end
+
+        def register_image(path)
+          return @images[path] if @images.key?(path)
+
+          resolved = resolve_image_for_pdfrb(path)
+          return nil unless resolved
+
+          @images[path] = @document.images.add(resolved)
+        rescue StandardError => e
+          Arrolio::Logger.warn "register_image failed for #{path}: #{e.class}: #{e.message[0, 80]}"
+          nil
+        end
+
+        # Pdfrb supports JPEG, PNG, and PDF — not SVG. If +path+ is an
+        # SVG file, rasterize it to PNG via rsvg-convert and cache the
+        # result. Returns the path to a pdfrb-compatible image file.
+        def resolve_image_for_pdfrb(path)
+          return path unless path.to_s.end_with?('.svg', '.SVG')
+          return path unless File.exist?(path)
+
+          png_path = svg_to_png_cache_path(path)
+          return png_path if File.exist?(png_path)
+
+          rasterize_svg(path, png_path)
+          File.exist?(png_path) ? png_path : path
+        end
+
+        def svg_to_png_cache_path(svg_path)
+          digest = Digest::MD5.file(svg_path).hexdigest
+          File.join(Dir.tmpdir, 'arrolio-svg-' + digest + '.png')
+        end
+
+        def rasterize_svg(svg_path, png_path)
+          require 'open3'
+          result = Open3.capture3('rsvg-convert', '-d', '96', '-p', '96',
+                                  '-o', png_path, svg_path)
+          return if result[2].success?
+
+          Arrolio::Logger.warn "rsvg-convert failed: #{result[1]}"
+        rescue StandardError => e
+          Arrolio::Logger.warn "rasterize_svg failed: #{e.class}: #{e.message[0, 80]}"
+        end
+
+        def cover_logo_style
+          return @cover_logo_style if @cover_logo_style
+
+          config = @layout_spec&.cover_logo_config || {}
+          width_mm = config['width_mm'] || 35.0
+          ratio = config['aspect_ratio'] || (1459.0 / 1667.0)
+          margin_mm = config['margin_mm'] || 25.5
+          @cover_logo_style = {
+            width: width_mm * MM_TO_PT,
+            height: width_mm * ratio * MM_TO_PT,
+            margin: margin_mm * MM_TO_PT
+          }.freeze
+        end
+
+        def render_cover_logo(canvas, page)
+          logo_style = cover_logo_style
+          w = logo_style[:width]
+          h = logo_style[:height]
+          margin = logo_style[:margin]
+          x = page.width - margin - w
+          y = page.height - margin - h
+          invoke = invoke_xobject_op
+          return unless invoke
+
+          canvas.save_graphics_state do
+            canvas.concat(w, 0, 0, h, x, y)
+            canvas.emit_op(invoke, @logo_ref)
+          end
+        rescue StandardError => e
+          Arrolio::Logger.warn "logo render failed: #{e.class}: #{e.message[0, 80]}"
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/renderer/pdf/font_embedding.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    class Pdf
+      # Extracted concern: Pdfrb coupling points kept out of the
+      # emission path.
+      module FontEmbedding
+        # Pre-scan all pages, collect codepoints per font family,
+        # then call Font::Embedder for each font_path.
+        def prepare_embedded_fonts(pages)
+          return if @font_paths.empty?
+
+          codepoints = Hash.new { |h, k| h[k] = [] }
+          pages.each { |page| collect_codepoints(page, codepoints) }
+          Arrolio::Logger.debug "collected codepoints for fonts: #{codepoints.keys.inspect}"
+          @font_paths.each do |font_name, path|
+            exists = File.exist?(path)
+            has_cp = codepoints.key?(font_name)
+            cp_count = codepoints[font_name]&.length || 0
+            Arrolio::Logger.debug "font #{font_name}: exists=#{exists} cp=#{cp_count}"
+            next unless exists
+            next unless has_cp
+
+            cps = codepoints[font_name].uniq
+            embedder = Font::Embedder.new(@document, path,
+                                          base_font_name: font_name)
+            ref = embedder.embed(cps)
+            attach_to_resources(font_name, ref)
+            @font_embedders[font_name] = embedder
+            @font_encoders[font_name] = Font::TextEncoder.new(embedder)
+            @font_refs[font_name] = ref
+          rescue StandardError => e
+            Arrolio::Logger.warn "embed failed for #{font_name}: #{e.class}: #{e.message[0,100]}"
+            Arrolio::Logger.debug e.backtrace.first(5).join("\n")
+          end
+        end
+
+        def attach_to_resources(font_name, ref)
+          catalog = @document.catalog
+          res = catalog.value[:Resources]
+          Arrolio::Logger.debug "attach_to_resources: Resources=#{res.class}"
+          unless res.is_a?(Hash) && res[:Font].is_a?(Hash)
+            catalog.value[:Resources] = { Font: {} }
+          end
+          font_hash = catalog.value[:Resources][:Font]
+          key = (format('EF%d', (font_hash.length + 1))).to_sym
+          font_hash[key] = ref
+          @embedded_resource_keys ||= {}
+          @embedded_resource_keys[font_name] = key
+        end
+
+        def collect_codepoints(page, by_font)
+          (page.static_regions.values + page.regions.values).each do |region|
+            region.placed_boxes.each do |box|
+              next unless box.kind == :text
+              next unless box.data.is_a?(Hash) && box.data[:lines]
+
+              box.data[:lines].each do |line|
+                next unless line.is_a?(TextLayout::Line)
+                line.placed_runs.each do |pr|
+                  next unless pr.run.is_a?(InlineRun)
+                  # Collect under the RUN'S font name, not the
+                  # paragraph's. Italic/bold runs have different
+                  # font_names and need their own subsets.
+                  run_font = pr.run.style.font_name
+                  next unless @font_paths.key?(run_font)
+                  pr.run.text.each_codepoint { |cp| by_font[run_font] << cp }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arrolio/renderer/pdf/metadata.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Renderer
+    class Pdf
+      # Extracted concern: Pdfrb coupling points kept out of the
+      # emission path.
+      module Metadata
+        def apply_metadata(metadata)
+          info = @document.catalog.value[:Info]
+          info ||= @document.add({})
+          @document.catalog.value[:Info] = info
+          info.value[:Title] = metadata[:title] if metadata[:title]
+          info.value[:Author] = metadata[:author] if metadata[:author]
+          info.value[:Creator] = 'Arrolio (Ruby)'
+          info.value[:Producer] = 'Arrolio + Pdfrb'
+        end
+
+        # Emit an XMP metadata packet (RDF/XML) as a stream on the
+        # catalog's /Metadata entry. PDF readers use this for Dublin
+        # Core properties alongside the legacy /Info dict.
+        def attach_xmp_metadata(metadata)
+          xmp = XmpBuilder.new(metadata).build
+          stream = @document.add(
+            { Type: :Metadata, Subtype: :XML, Length: xmp.bytesize },
+            type: Pdfrb::Model::Cos::Stream
+          )
+          stream.stream = xmp
+          @document.catalog.value[:Metadata] =
+            Pdfrb::Model::Reference.new(stream.oid, stream.gen)
+        rescue StandardError => e
+          Arrolio::Logger.warn "XMP attach failed: #{e.class}: #{e.message[0, 80]}"
+        end
+
+        def build_outline(context, _pages)
+          entries = context.heading_entries
+          return unless entries&.any?
+
+          pdfrb_pages = @document.pages.to_a
+          ob = OutlineBuilder.new(document: @document,
+                                  entries: entries,
+                                  pdfrb_pages: pdfrb_pages)
+          result = ob.build
+          Arrolio::Logger.debug "outline build returned: #{result.class}"
+        rescue StandardError => e
+          Arrolio::Logger.warn "outline build failed: #{e.class}: #{e.message[0,150]}"
+          Arrolio::Logger.debug e.backtrace.first(5).join("\n")
+        end
+      end
+    end
+  end
+end