arrolio 0.1.0 → 0.1.2

data/lib/arrolio/text_layout/greedy.rb

@@ -100,11 +100,25 @@ module Arrolio
           next if slice.nil? || slice.empty?
 
           sub_run = InlineRun.new(slice, style: run.style)
-          placed << Line::PlacedRun.new(run: sub_run, x_offset: x_offset)
+          placed << Line::PlacedRun.new(run: sub_run, x_offset: x_offset,
+                                        chunk_widths: chunk_widths(run, slice))
           x_offset += sub_run.width(@measurer)
         end
         placed
       end
+
+      # Width of each emission chunk (text split after
+      # whitespace) — the same chunking the renderer uses. The
+      # breaker owns measurement; the renderer advances by these.
+      def chunk_widths(run, slice)
+        font = run.style.font_name
+        size = run.style.font_size * run.font_size_scale
+        slice.split(/(?<=\s)(?=\S)/).map do |chunk|
+          @measurer.width_of_run(chunk, font_size: size,
+                                        character_spacing: run.style.character_spacing,
+                                        word_spacing: 0, font_name: font)
+        end
+      end
     end
   end
 end

data/lib/arrolio/text_layout/knuth_plass/breaker.rb

@@ -12,20 +12,38 @@ module Arrolio
       # converges in O(n) for typical text because most candidate
       # breaks are pruned early.
       #
+      # When no break sequence is feasible within TOLERANCE (every
+      # candidate line is too loose), a second pass runs with
+      # emergency stretch added to every line's stretchability —
+      # TeX's \emergencystretch. Without it, the only surviving path
+      # is the forced final break, which packs the whole paragraph
+      # into one overfull line and silently runs off the page.
+      #
       # Produces TextLayout::Line[] output — compatible with the
       # existing Greedy breaker so the engine can swap freely.
       class Breaker
         Infinity = Float::INFINITY
 
-        # Tolerance for adjustment ratio — lines with ratio above
-        # this are considered "underfull" and penalized.
-        TOLERANCE = 100.0
+        # Tolerance for adjustment ratio — lines with |ratio| above
+        # this are infeasible and rejected. Standard TeX default
+        # (\tolerance=200) maps to ratio ≈ 1.26 because badness is
+        # 100*|r|^3. We use a slightly looser limit (2.5) to allow
+        # reasonable stretch on tight paragraphs while rejecting
+        # the pathological overfills greedy avoids by construction.
+        TOLERANCE = 2.5
+
+        # Stretch added to every line during the emergency pass.
+        # Comparable to TeX's \emergencystretch = 2em at body size.
+        EMERGENCY_STRETCH = 20.0
 
         # Extra penalty for consecutive flagged breaks (hyphens).
         FLAGGED_PENALTY = 3000.0
 
-        # Extra penalty for the last line being underfull.
-        DEMERITS_LAST_LINE = 50.0
+        # Last-resort cost for a forced break landing an overfull
+        # line (ratio beyond the available shrink). Must exceed the
+        # worst badness demerits ((1+10000)^2 = 1e8) so ANY
+        # breakable alternative wins.
+        OVERFULL_FORCED_PENALTY = 1_000_000_000.0
 
         attr_reader :items, :line_widths, :runs, :measurer, :align
 
@@ -44,51 +62,86 @@ module Arrolio
         end
 
         def layout
-          nodes = active_nodes
-          return [] if nodes.empty?
-
-          # Only consider nodes that reached the end of the items
-          # (the FINISHED penalty at the last position).
-          final_nodes = nodes.select { |n| n.position == @items.length - 1 }
-          return [] if final_nodes.empty?
-
-          # Backtrack from the best final node.
-          breaks = reconstruct_breaks(best_final_node(final_nodes))
+          build_prefix_sums
+          node = solve
+          node = solve(emergency_stretch: EMERGENCY_STRETCH) unless feasible?(node)
+          return [] if node.nil?
 
-          # Build Line objects from the break points.
-          lines = []
-          prev_item = 0
-          breaks.each_with_index do |br, line_idx|
-            width = line_width_for(line_idx)
-            placed = build_placed_runs(prev_item, br, width)
-            used = compute_line_width(prev_item, br)
-            lines << Line.new(placed, width: used, max_width: width, align: @align)
-            prev_item = br
-          end
-          lines
+          build_lines(node)
         end
 
         # Internal: a node in the dynamic programming graph.
         Node = Struct.new(:position, :line, :fitness, :total_demerits,
                           :previous, keyword_init: true)
 
+        # Internal: a run of same-signature text being merged into a
+        # single PlacedRun (one canvas.text call at render time).
+        RunGroup = Struct.new(:signature, :text, :x_offset, :chunk_widths,
+                              keyword_init: true)
+
         private
 
         # Active-node dynamic programming. Each active node represents
         # a feasible break position. We iterate through items and
         # try breaking at each feasible position.
-        def active_nodes
-          @active = [Node.new(position: -1, line: 0, fitness: 1,
-                              total_demerits: 0, previous: nil)]
-          @items.each_with_index do |_item, i|
+        def solve(emergency_stretch: 0.0)
+          @emergency_stretch = emergency_stretch.to_f
+          # The emergency pass accepts any STRETCH ratio (TeX's
+          # \emergencystretch philosophy: a loose line beats an
+          # overfull one). A fixed stretch budget alone cannot
+          # bridge the dead zone between over-shrunk and too-loose
+          # breaks when candidates sit far short of the measure.
+          @stretch_limit = emergency_stretch.positive? ? Float::INFINITY : TOLERANCE
+          active = [Node.new(position: -1, line: 0, fitness: 1,
+                             total_demerits: 0, previous: nil)]
+          @items.each_with_index do |item, i|
             next unless feasible_break?(i)
 
-            @active = @active.reject { |a| prune?(a, i) }
-            candidates = @active.filter_map { |a| try_break(a, i) }
-            best = best_candidate(candidates)
-            @active << best if best
+            best = best_candidate(active.filter_map { |a| try_break(a, i) })
+            next unless best
+
+            if item.penalty? && item.forced_break?
+              # A forced break must be taken: no earlier active node
+              # may span across it (otherwise the DP happily skips
+              # forced breaks when the parfill glue makes the single
+              # line feasible).
+              active = [best]
+            else
+              active << best
+            end
+          end
+          best_final_node(active.select { |n| n.position == @items.length - 1 })
+        end
+
+        # True when the solution contains no line whose adjustment
+        # ratio escaped TOLERANCE via a forced break. When false, the
+        # paragraph needs the emergency pass.
+        def feasible?(final_node)
+          return false if final_node.nil?
+
+          prev_item = 0
+          reconstruct_breaks(final_node).each_with_index do |br, line_idx|
+            natural = compute_line_width(prev_item, br)
+            ratio = adjustment_ratio(natural, line_width_for(line_idx),
+                                     prev_item, br)
+            return false if ratio.abs > TOLERANCE
+
+            prev_item = br
           end
-          @active
+          true
+        end
+
+        def build_lines(final_node)
+          lines = []
+          prev_item = 0
+          reconstruct_breaks(final_node).each_with_index do |br, line_idx|
+            width = line_width_for(line_idx)
+            placed = build_placed_runs(prev_item, br)
+            lines << Line.new(placed, width: compute_line_width(prev_item, br),
+                                      max_width: width, align: @align)
+            prev_item = br
+          end
+          lines
         end
 
         def feasible_break?(i)
@@ -96,33 +149,37 @@ module Arrolio
           (item.penalty? && !item.no_break?) || (item.glue? && i.positive? && @items[i - 1].box?)
         end
 
-        def prune?(node, _current)
-          node.line >= @line_widths.length + 10
-        end
-
         def try_break(node, break_pos)
           item = @items[break_pos]
           width = line_width_for(node.line)
-          line_w = compute_line_width(node.position + 1, break_pos)
+          line_start = node.position + 1
+          line_w = compute_line_width(line_start, break_pos)
 
           is_forced = item.penalty? && item.forced_break?
-          ratio = adjustment_ratio(line_w, width, break_pos)
+          ratio = adjustment_ratio(line_w, width, line_start, break_pos)
 
           # Forced breaks are always accepted but still penalized
           # for bad ratios so the algorithm prefers shorter lines.
-          unless is_forced
-            return nil if ratio.abs > TOLERANCE
-          end
-
-          ratio = 0.0 if ratio == Infinity || ratio == -Infinity
+          # TeX semantics: shrink is a hard limit (ratio < -1 needs
+          # more compression than the glue has - an overfull box),
+          # stretch is soft up to TOLERANCE. Allowing ratio < -1
+          # made the DP prefer overfull compression over loose
+          # lines (clamped badness scores compression cheaper).
+          return nil if !is_forced && (ratio > @stretch_limit || ratio < -1.0)
+
+          ratio = 0.0 if ratio.infinite?
           demerits = demerits_for(ratio, break_pos)
+          # A forced break is always TAKEN (correctness) but an
+          # overfull line through it is a last resort: without this,
+          # free shrink made the DP pack whole paragraphs onto one
+          # line via the un-rejectable final penalty.
+          demerits += OVERFULL_FORCED_PENALTY if is_forced && ratio < -1.0
           total = node.total_demerits + demerits
-          fitness = fitness_class(ratio)
 
           Node.new(
             position: break_pos,
             line: node.line + 1,
-            fitness: fitness,
+            fitness: fitness_class(ratio),
             total_demerits: total,
             previous: node
           )
@@ -137,10 +194,11 @@ module Arrolio
         end
 
         # Adjustment ratio: how stretched (positive) or shrunk
-        # (negative) a line is. 0 = perfect fit.
-        def adjustment_ratio(natural_width, target_width, break_pos)
-          glue_stretch = total_stretch(break_pos)
-          glue_shrink = total_shrink(break_pos)
+        # (negative) a line is. 0 = perfect fit. Emergency stretch
+        # widens the feasibility window without changing shrink.
+        def adjustment_ratio(natural_width, target_width, line_start, line_end)
+          glue_stretch = line_stretch(line_start, line_end) + @emergency_stretch
+          glue_shrink = line_shrink(line_start, line_end)
 
           if natural_width < target_width
             glue_stretch.positive? ? (target_width - natural_width) / glue_stretch : Infinity
@@ -153,10 +211,14 @@ module Arrolio
 
         def demerits_for(ratio, break_pos)
           penalty = @items[break_pos].penalty? ? @items[break_pos].penalty : 0
+          # FOP justifies every line to the measure after breaking:
+          # shrink (ratio < 0) is free, unlike TeX's cubic badness.
+          # Penalizing it made the DP prefer an extra loose line
+          # where the reference compresses (5.6's 4-line vs our 5).
           badness = if ratio.negative?
-            (100 * ((-ratio) ** 3)).to_i
-          else
-            0
+                      0
+                    else
+                      (100 * (ratio ** 3)).clamp(0, 10_000).to_i
                     end
           # Standard Knuth-Plass demerits. Forced breaks (penalty =
           # -Infinity) use d = (1 + badness)^2 — the penalty term
@@ -181,21 +243,25 @@ module Arrolio
           end
         end
 
+        # Prefix sums so range width/stretch/shrink queries are O(1).
+        def build_prefix_sums
+          @prefix_width = [0.0]
+          @prefix_stretch = [0.0]
+          @prefix_shrink = [0.0]
+          @items.each do |item|
+            @prefix_width << (@prefix_width.last + item.width.to_f)
+            @prefix_stretch << (@prefix_stretch.last + (item.glue? ? item.stretch : 0.0))
+            @prefix_shrink << (@prefix_shrink.last + (item.glue? ? item.shrink : 0.0))
+          end
+        end
+
         # Sum of widths from item +start+ to item +stop+ (exclusive).
         # Discards trailing glue at the break point.
         def compute_line_width(start, stop)
           return 0.0 if start >= stop
 
-          sum = 0.0
-          (start...stop).each do |i|
-            item = @items[i]
-            next if item.nil?
-
-            # Trailing glue after last box is discarded at break.
-            last_box = last_box_index_in(start, stop)
-            sum += item.width if i <= last_box
-          end
-          sum
+          last_box = last_box_index_in(start, stop)
+          last_box < start ? 0.0 : @prefix_width[last_box + 1] - @prefix_width[start]
         end
 
         def last_box_index_in(start, stop)
@@ -206,16 +272,12 @@ module Arrolio
           idx
         end
 
-        def total_stretch(break_pos)
-          sum = 0.0
-          @items[0..break_pos].each { |item| sum += item.stretch if item.glue? }
-          sum
+        def line_stretch(line_start, line_end)
+          @prefix_stretch[line_end] - @prefix_stretch[line_start]
         end
 
-        def total_shrink(break_pos)
-          sum = 0.0
-          @items[0..break_pos].each { |item| sum += item.shrink if item.glue? }
-          sum
+        def line_shrink(line_start, line_end)
+          @prefix_shrink[line_end] - @prefix_shrink[line_start]
         end
 
         def line_width_for(line_idx)
@@ -232,32 +294,94 @@ module Arrolio
           breaks.reverse
         end
 
-        def build_placed_runs(start_item, stop_item, _width)
+        # Merges contiguous Box + Glue items into PlacedRuns — one
+        # canvas.text call per group — so pdftotext sees word
+        # separators instead of glued-together Tj fragments. A new
+        # group starts whenever the rendering signature (style,
+        # baseline shift, scale, href) changes, so bold/italic and
+        # sub/superscript runs keep their formatting. Glue past the
+        # line's last box (at the break) is dropped: it is discarded
+        # by width accounting and would otherwise inflate the
+        # renderer's justify word count.
+        # Chunk widths follow the emission chunking (text split
+        # AFTER whitespace): a chunk's width is its boxes plus the
+        # trailing glue(s). Hyphen parts join the same chunk (no
+        # space between them).
+        def build_placed_runs(start_item, stop_item)
+          last_box = last_box_index_in(start_item, stop_item)
           placed = []
-          x_offset = 0.0
+          group = nil
+          open_w = 0.0
+          close_pending = false
+
           (start_item...stop_item).each do |i|
             item = @items[i]
-            next unless item&.box?
-
-            run = @runs[item.run_index]
-            next unless run
-
-            slice = run.text[item.char_offset, item.char_length]
-            next if slice.nil? || slice.empty?
-
-            sub = InlineRun.new(slice, style: run.style,
-                                       baseline_shift: run.baseline_shift,
-                                       font_size_scale: run.font_size_scale,
-                                       href: run.href)
-            placed << Line::PlacedRun.new(run: sub, x_offset: x_offset)
-            x_offset += item.width
+            next unless item
+            next if item.glue? && item.stretch.infinite?
+
+            if item.box?
+              run = @runs[item.run_index]
+              next unless run
+
+              slice = run.text[item.char_offset, item.char_length]
+              next if slice.nil? || slice.empty?
+
+              signature = [run.style, run.baseline_shift,
+                           run.font_size_scale, run.href]
+              if group.nil? || group.signature != signature
+                flush_placed_group(placed, group) if group
+                group = RunGroup.new(signature: signature, text: String.new,
+                                     x_offset: item_offset(first_box_in(start_item, stop_item), i),
+                                     chunk_widths: [])
+                open_w = 0.0
+                close_pending = false
+              end
+              if close_pending
+                group.chunk_widths << open_w
+                open_w = 0.0
+                close_pending = false
+              end
+              group.text << slice
+              open_w += item.width.to_f
+            elsif item.glue? && group && i < last_box
+              group.text << ' '
+              open_w += item.width.to_f
+              close_pending = true
+            end
+          end
+          if group
+            group.chunk_widths << open_w if close_pending || open_w.positive?
+            flush_placed_group(placed, group)
           end
           placed
         end
 
-        def finalize_node(position, line, fitness, total_demerits, previous)
-          Node.new(position: position, line: line, fitness: fitness,
-                   total_demerits: total_demerits, previous: previous)
+        # Offsets are relative to the line's FIRST BOX, not the
+        # break-following item: the leading glue is discarded at a
+        # break, and pricing it shifted every continuation line
+        # right by one space width (a phantom indent that also
+        # shortened the measure and caused extra wraps).
+        def first_box_in(start_item, stop_item)
+          (start_item...stop_item).each do |i|
+            return i if @items[i]&.box?
+          end
+          start_item
+        end
+
+        def item_offset(start_item, item_idx)
+          @prefix_width[item_idx] - @prefix_width[start_item]
+        end
+
+        def flush_placed_group(placed, group)
+          return if group.text.empty?
+
+          style, baseline_shift, font_size_scale, href = group.signature
+          run = InlineRun.new(group.text, style: style,
+                                          baseline_shift: baseline_shift,
+                                          font_size_scale: font_size_scale,
+                                          href: href)
+          placed << Line::PlacedRun.new(run: run, x_offset: group.x_offset,
+                                        chunk_widths: group.chunk_widths)
         end
       end
     end

data/lib/arrolio/text_layout/knuth_plass/item_builder.rb

@@ -22,6 +22,12 @@ module Arrolio
           @runs.each_with_index do |run, run_idx|
             build_items_for_run(run, run_idx, items)
           end
+          # Parfillskip: zero-width glue with infinite stretch before
+          # the FINISHED penalty (TeX's \parfillskip). Makes the last
+          # line of a paragraph never loose, so short final lines are
+          # always feasible. Paragraphs with no feasible intermediate
+          # break are rescued by Breaker's emergency-stretch pass.
+          items << Glue.new(width: 0, stretch: Float::INFINITY, shrink: 0)
           items << FINISHED
           items
         end
@@ -38,6 +44,26 @@ module Arrolio
             return
           end
 
+          build_word_items(run, run_idx, text, 0, items)
+        end
+
+        # A run with embedded newlines wraps WITHIN each segment
+        # (a segment can be a whole paragraph) and places a forced
+        # break between segments. Emitting each segment as a single
+        # box made long segments unbreakable overfull lines.
+        def build_newline_items(run, run_idx, text, items)
+          # -1 keeps trailing empty segments: a lone "\n" run
+          # must still emit its forced-break penalty.
+          segments = text.split("\n", -1)
+          base = 0
+          segments.each_with_index do |seg, i|
+            build_word_items(run, run_idx, seg, base, items) unless seg.empty?
+            base += seg.length + 1
+            items << Penalty.new(penalty: -Float::INFINITY, run_index: run_idx) if i < segments.length - 1
+          end
+        end
+
+        def build_word_items(run, run_idx, text, base_offset, items)
           words = text.split(/(\s+)/)
           offset = 0
           words.each do |word|
@@ -46,31 +72,18 @@ module Arrolio
               stretch = measure(' ', run) * 0.5
               shrink = measure(' ', run) * 0.33
               items << Glue.new(width: width, stretch: stretch, shrink: shrink,
-                                run_index: run_idx, char_offset: offset)
+                                run_index: run_idx, char_offset: base_offset + offset)
             elsif word.include?('-')
-              build_hyphenated_word(word, run, run_idx, offset, items)
+              build_hyphenated_word(word, run, run_idx, base_offset + offset, items)
             elsif !word.empty?
               width = measure(word, run)
               items << Box.new(width: width, run_index: run_idx,
-                               char_offset: offset, char_length: word.length)
+                               char_offset: base_offset + offset, char_length: word.length)
             end
             offset += word.length
           end
         end
 
-        def build_newline_items(run, run_idx, text, items)
-          segments = text.split("\n")
-          segments.each_with_index do |seg, i|
-            unless seg.empty?
-              width = measure(seg, run)
-              items << Box.new(width: width, run_index: run_idx,
-                               char_offset: text.index(seg) || 0,
-                               char_length: seg.length)
-            end
-            items << Penalty.new(penalty: -Float::INFINITY, run_index: run_idx) if i < segments.length - 1
-          end
-        end
-
         def build_hyphenated_word(word, run, run_idx, offset, items)
           parts = word.split(/(-)/)
           part_offset = offset
@@ -94,7 +107,8 @@ module Arrolio
             text,
             font_size: run.style.font_size * run.font_size_scale,
             character_spacing: run.style.character_spacing,
-            word_spacing: 0
+            word_spacing: 0,
+            font_name: run.style.font_name
           )
         end
       end

data/lib/arrolio/text_layout/knuth_plass.rb

@@ -5,6 +5,9 @@ module Arrolio
   module TextLayout
     module KnuthPlass
       autoload :Item, 'arrolio/text_layout/knuth_plass/item'
+      autoload :Box, 'arrolio/text_layout/knuth_plass/item'
+      autoload :Glue, 'arrolio/text_layout/knuth_plass/item'
+      autoload :Penalty, 'arrolio/text_layout/knuth_plass/item'
       autoload :Breaker, 'arrolio/text_layout/knuth_plass/breaker'
       autoload :ItemBuilder, 'arrolio/text_layout/knuth_plass/item_builder'
     end

data/lib/arrolio/text_layout/line.rb

@@ -5,7 +5,13 @@ module Arrolio
     # One laid-out line: a list of PlacedRun tuples plus the
     # line's content width, target width, and alignment.
     class Line
-      PlacedRun = Struct.new(:run, :x_offset, keyword_init: true) do
+      # +chunk_widths+ carries the width of each emission chunk
+      # (text split after whitespace), computed by the BREAKER that
+      # owns glyph measurement. The renderer advances by these
+      # widths — it never measures, so layout and render cannot
+      # drift apart (the source of the word-overlap and
+      # measure-overflow bugs).
+      PlacedRun = Struct.new(:run, :x_offset, :chunk_widths, keyword_init: true) do
         def freeze
           run.freeze
           super
@@ -38,9 +44,11 @@ module Arrolio
         @align == :justify
       end
 
+      # Negative when the line is overfull (TeX shrink): the
+      # renderer compresses inter-word gaps. Clamping at zero made
+      # compressed lines draw at natural width, past the measure.
       def justify_stretch
         return 0.0 unless justified?
-        return 0.0 if @width >= @max_width
 
         gaps = word_gap_count
         return 0.0 if gaps.zero?

data/lib/arrolio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Arrolio
-  VERSION = '0.1.0'
+  VERSION = '0.1.2'
 end

data/lib/arrolio.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require 'pdfrb'
+require 'pdfrb/content/operators'
+require 'mml'
 
 # Arrolio -- a flavor-agnostic paged-media layout engine.
-# Core knows NOTHING about specific document formats (OIML,
-# ISO, IEC, BSI). Flavors are loaded on demand:
-#   require 'arroolio'
-#   require 'arrolio/oiml'  # Load the OIML flavor
+# Core knows NOTHING about specific document formats. Each flavor
+# lives in its own directory (XSL + 3 generated YAML files) outside
+# the gem and is rendered via Arrolio::ConfigDrivenPipeline.
 module Arrolio
   autoload :VERSION, 'arrolio/version'
   autoload :Error, 'arrolio/error'
@@ -36,7 +37,10 @@ module Arrolio
   autoload :AssetResolver, 'arrolio/asset_resolver'
   autoload :GenericAdapter, 'arrolio/generic_adapter'
   autoload :GenericFlowBuilder, 'arrolio/generic_flow_builder'
+  autoload :EmbeddedBlockExtractor, 'arrolio/embedded_block_extractor'
   autoload :ConfigDrivenPipeline, 'arrolio/config_driven_pipeline'
   autoload :TocBuilder, 'arrolio/toc_builder'
+  autoload :FontScanner, 'arrolio/font_scanner'
   autoload :Composer, 'arrolio/composer'
+  autoload :MathML, 'arrolio/math_ml'
 end

data/scripts/parity_check.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'arrolio'
+require 'fileutils'
+
+module ParityCheck
+  REFERENCE = File.expand_path('~/src/mn/mn-samples-oiml/_site/documents/r060/1/document.pdf')
+  FIXTURE = File.expand_path('~/src/mn/mn-samples-oiml/_site/documents/r060/1/document.presentation.xml')
+  SOURCE_DIR = File.expand_path('~/src/mn/mn-samples-oiml/sources/r060/1')
+  FLAVOR_DIR = File.expand_path('../flavors/oiml', __dir__)
+  OUTPUT = File.expand_path('../tmp/parity_check.pdf', __dir__)
+
+  def self.run
+    unless File.exist?(REFERENCE) && File.exist?(FIXTURE)
+      warn 'OIML fixture or reference PDF not found. Skipping parity check.'
+      warn "  Reference: #{REFERENCE}" unless File.exist?(REFERENCE)
+      warn "  Fixture:   #{FIXTURE}" unless File.exist?(FIXTURE)
+      return
+    end
+
+    FileUtils.mkdir_p(File.dirname(OUTPUT))
+    xml = File.read(FIXTURE)
+    Arrolio::ConfigDrivenPipeline.render(
+      xml,
+      io: OUTPUT,
+      flavor_dir: FLAVOR_DIR,
+      input_path: FIXTURE,
+      extra_image_dirs: [SOURCE_DIR]
+    )
+
+    require 'arrolio/harness'
+    diff = Arrolio::Harness::PdfDiff.new(OUTPUT, REFERENCE)
+    result = diff.call
+
+    puts "Overall similarity: #{(result.overall_similarity * 100).round(2)}%"
+    puts "Our pages: #{result.ours_pages}, Reference pages: #{result.theirs_pages}"
+    puts ''
+    result.per_page.each do |page|
+      pct = (page.similarity * 100).round(1)
+      status = if page.similarity > 0.5 then 'OK'
+               elsif page.similarity > 0.1 then 'PARTIAL'
+               else 'LOW'
+               end
+      puts "  Page #{page.number}: #{pct}% [#{status}]"
+    end
+    puts ''
+    puts 'Target: > 50% overall similarity'
+    result.overall_similarity
+  end
+end
+
+ParityCheck.run