przn 0.4.0 → 0.6.0

data/lib/przn/screenshot_pdf_exporter.rb

@@ -2,6 +2,8 @@
 
 require 'tmpdir'
 require 'fileutils'
+require 'digest'
+require 'zlib'
 
 module Przn
   # Default PDF export: drives the live renderer, asks the terminal to save
@@ -10,11 +12,11 @@ module Przn
   # Requires Echoes (or any terminal that implements the same capture
   # command); use `export_pdf_prawn` instead for environments where that's
   # not possible (CI, headless).
-  def self.export_pdf(file, output, theme: nil)
+  def self.export_pdf(file, output, theme: nil, quality: nil)
     markdown = File.read(file)
     presentation = Parser.parse(markdown)
     base_dir = File.dirname(File.expand_path(file))
-    ScreenshotPdfExporter.new(presentation, base_dir: base_dir, theme: theme).export(output)
+    ScreenshotPdfExporter.new(presentation, base_dir: base_dir, theme: theme, quality: quality).export(output)
     puts "Generated: #{output}"
   end
 
@@ -43,12 +45,27 @@ module Przn
     POLL_INTERVAL = 0.05  # seconds between file-existence checks
     CAPTURE_TIMEOUT = 10  # seconds per slide before giving up
 
-    def initialize(presentation, base_dir: '.', theme: nil, terminal: nil)
+    # Maps the user-facing `--pdf-quality` flag onto Ghostscript's
+    # `-dPDFSETTINGS` preset names. `:lossless` skips the gs pass
+    # entirely (lossless HexaPDF layers only — useful when image
+    # fidelity matters more than file size). `nil` means "use the
+    # default", which is `:medium`.
+    QUALITY_PRESETS = {
+      'lossless' => :lossless,
+      'low'      => '/screen',
+      'medium'   => '/ebook',
+      'high'     => '/printer',
+      'max'      => '/prepress',
+    }.freeze
+    DEFAULT_QUALITY = 'medium'
+
+    def initialize(presentation, base_dir: '.', theme: nil, terminal: nil, quality: nil)
       @presentation = presentation
       @base_dir = base_dir
       @theme = theme || Theme.default
       @terminal = terminal || Terminal.new
-      @renderer = Renderer.new(@terminal, base_dir: base_dir, theme: theme)
+      @renderer = Renderer.new(@terminal, base_dir: base_dir, theme: theme, export_mode: true, presentation: presentation)
+      @quality = resolve_quality(quality)
     end
 
     def export(output_path)
@@ -68,7 +85,10 @@ module Przn
       @terminal.hide_cursor
       @presentation.slides.each_with_index do |slide, i|
         pdf_path = File.join(dir, format('slide-%04d.pdf', i))
-        @renderer.render(slide, current: i, total: @presentation.total)
+        # Render at the final reveal — a PDF is a static artifact, so
+        # every `<wait/>` step should already be visible on the page.
+        final_step = @renderer.step_count(slide) - 1
+        @renderer.render(slide, current: i, total: @presentation.total, step: final_step)
         request_capture(pdf_path)
         wait_for_capture(pdf_path)
         paths << pdf_path
@@ -76,6 +96,7 @@ module Przn
       paths
     ensure
       @terminal.write "#{OSC};bg-clear#{BEL}"
+      @terminal.write ImageUtil.kitty_clear_all if ImageUtil.kitty_terminal?
       @terminal.show_cursor
       @terminal.leave_alt_screen
       @terminal.flush
@@ -109,7 +130,154 @@ module Przn
           output.pages << output.import(page)
         end
       end
+
+      # Three lossless passes before write. Page surfaces stay
+      # byte-identical; only the encoding of the underlying objects
+      # shrinks.
+      #   1. Dedup image XObjects — repeated logos / shared backgrounds
+      #      become a single shared object.
+      #   2. Re-Flate uncompressed image streams.
+      #   3. HexaPDF's task(:optimize) collapses metadata into object
+      #      streams and rewrites xref as binary streams.
+      dedup_image_xobjects(output)
+      reflate_uncompressed_images(output)
+      output.task(:optimize,
+                  compact: true,
+                  object_streams: :generate,
+                  xref_streams: :generate)
+
       output.write(output_path)
+
+      # Optional lossy post-process. Echoes' OSC 7772 capture embeds
+      # `<img>` and shape rasters at their NATIVE source resolution
+      # (a 24-megapixel phone photo embedded as a slide thumbnail
+      # stays at 24MP in the captured PDF). Re-Flating that pixel
+      # data, as the three lossless passes above do, doesn't help —
+      # photographic content compresses 10-50× better as JPEG.
+      #
+      # Ghostscript's `-dPDFSETTINGS=/ebook` downsamples raster
+      # images to 150 DPI and re-encodes them as JPEG. We shell out
+      # if `gs` is on PATH; if not, the file is left as-is with a
+      # friendly hint on stderr. Lossy in the strict sense, but the
+      # `/ebook` preset is widely considered visually indistinguishable
+      # at presentation viewing distances.
+      shrink_with_ghostscript(output_path)
+    end
+
+    # Resolve the Ghostscript binary path the recompression pass will
+    # use. Three layers, in order:
+    #   1. `PRZN_GS=` (explicitly empty) — opt out, no warning. Used
+    #      by tests and by anyone who wants the lossless-only pipeline.
+    #   2. `PRZN_GS=<path>` — explicit override (custom build, brew
+    #      keg-only path, etc).
+    #   3. Default: probe PATH for `gs`. Missing binary → returns
+    #      :missing so the caller can print the install hint once.
+    def gs_path
+      env = ENV['PRZN_GS']
+      return :disabled if env == ''
+      bin = env && !env.empty? ? env : 'gs'
+      found = `which #{bin} 2>/dev/null`.chomp
+      found.empty? ? :missing : found
+    end
+
+    def shrink_with_ghostscript(path)
+      return if @quality == :lossless
+      gs = gs_path
+      case gs
+      when :disabled then return
+      when :missing
+        warn 'Hint: install Ghostscript (`brew install ghostscript`) for a 5-20× ' \
+             'size reduction on image-heavy decks. Skipping recompression. ' \
+             'Pass --pdf-quality lossless to silence this hint.'
+        return
+      end
+
+      tmp = "#{path}.gs.tmp"
+      ok = system(gs,
+                  '-q',
+                  '-dQUIET', '-dNOPAUSE', '-dBATCH', '-dSAFER',
+                  '-sDEVICE=pdfwrite',
+                  "-dPDFSETTINGS=#{@quality}",
+                  '-dCompatibilityLevel=1.5',
+                  "-sOutputFile=#{tmp}",
+                  path,
+                  out: File::NULL, err: File::NULL)
+      if ok && File.exist?(tmp) && File.size(tmp).positive? && File.size(tmp) < File.size(path)
+        FileUtils.mv(tmp, path)
+      else
+        FileUtils.rm_f(tmp)
+      end
+    end
+
+    def resolve_quality(raw)
+      key = (raw || DEFAULT_QUALITY).to_s.downcase
+      preset = QUALITY_PRESETS[key]
+      unless preset
+        raise ArgumentError,
+              "unknown --pdf-quality #{raw.inspect}; expected one of " \
+              "#{QUALITY_PRESETS.keys.join(', ')}"
+      end
+      preset
+    end
+
+    # Find image XObjects whose stream bytes are byte-for-byte identical
+    # and collapse them into a single shared object — the case being:
+    # a slide background or repeated logo gets captured into N
+    # per-slide PDFs independently, then HexaPDF imports each one as
+    # its own object. Hashing the stream bytes is enough to recognise
+    # them; the later pages' XObject resource entries are pointed at
+    # the first occurrence's indirect reference and the duplicate
+    # objects are swept by the subsequent compact-optimize pass.
+    def dedup_image_xobjects(doc)
+      by_hash = {}
+      doc.pages.each do |page|
+        resources = page[:Resources]
+        next unless resources && resources[:XObject]
+        xobjects = resources[:XObject]
+        xobjects.each do |name, xobj|
+          next unless image_xobject?(xobj)
+          h = Digest::SHA256.hexdigest(xobj.stream.to_s)
+          if (canonical = by_hash[h])
+            xobjects[name] = canonical unless canonical.equal?(xobj)
+          else
+            by_hash[h] = xobj
+          end
+        end
+      end
+      # Sweep the now-orphaned duplicates.
+      doc.task(:optimize, compact: true)
+    end
+
+    # Apply best-strength Flate to image streams that arrived
+    # uncompressed (or compressed by a filter Flate can outperform).
+    # JPEG (`DCTDecode`) and JPEG-2000 (`JPXDecode`) streams are
+    # already entropy-coded — re-encoding them losslessly cannot
+    # help and lossy re-encoding would need an external image
+    # library. Streams that grow under Flate (rare; happens when
+    # the input is already near maximum entropy) are left alone.
+    def reflate_uncompressed_images(doc)
+      doc.each do |obj|
+        next unless image_xobject?(obj)
+        filter = Array(obj[:Filter])
+        next if filter.include?(:FlateDecode) ||
+                filter.include?(:DCTDecode) ||
+                filter.include?(:JPXDecode)
+        raw = obj.stream.to_s
+        next if raw.empty?
+        deflated = Zlib::Deflate.deflate(raw, Zlib::BEST_COMPRESSION)
+        next if deflated.bytesize >= raw.bytesize
+        obj.stream = deflated
+        obj[:Filter] = :FlateDecode
+      end
+    end
+
+    def image_xobject?(obj)
+      # `doc.each` walks every indirect object, including HexaPDF::PDFArray
+      # whose `[]` raises on a Symbol key. Gate on the underlying value
+      # being a dict (Hash) before any keyed lookup so arrays and plain
+      # scalars are silently skipped.
+      return false unless obj.respond_to?(:value) && obj.value.is_a?(Hash)
+      obj[:Type] == :XObject && obj[:Subtype] == :Image
     end
   end
 end

data/lib/przn/slide.rb

@@ -2,10 +2,12 @@
 
 module Przn
   class Slide
-    attr_reader :blocks
+    attr_reader :blocks, :layout, :attrs
 
-    def initialize(blocks)
+    def initialize(blocks, layout: nil, attrs: {})
       @blocks = blocks.freeze
+      @layout = layout
+      @attrs = attrs.freeze
     end
 
     # Aggregate every `{::note}` / `<note>` segment in the slide's text-bearing

data/lib/przn/terminal.rb

@@ -5,6 +5,10 @@ require 'io/console'
 module Przn
   class Terminal
     MOUSE_OFF = "\e[?1006l\e[?1003l\e[?1002l\e[?1000l"
+    # Button-event tracking (1002: presses, releases, and motion only
+    # while a button is held — for dragging the 🐇) in SGR encoding
+    # (1006). Bare hovering is never reported.
+    MOUSE_ON = "\e[?1002h\e[?1006h"
 
     def initialize(input: $stdin, output: $stdout)
       @in = input
@@ -50,6 +54,12 @@ module Przn
       write MOUSE_OFF
     end
 
+    # Report clicks so the controller can page with the mouse. Cleared
+    # by `leave_alt_screen`'s MOUSE_OFF.
+    def enable_mouse
+      write MOUSE_ON
+    end
+
     def leave_alt_screen
       write MOUSE_OFF
       write "\e[?1049l"

data/lib/przn/theme.rb

@@ -6,7 +6,26 @@ module Przn
   class Theme
     DEFAULT_PATH = File.expand_path('../../../default_theme.yml', __FILE__)
 
-    attr_reader :colors, :font, :bullet, :background, :title, :rabbit
+    # A rectangular region inside a slide. `x` / `y` are stored as the
+    # raw strings from the YAML and resolved at render time against
+    # the current terminal width / height by the same helper that
+    # handles `<at x y>` and `<img x y>` coords — so `x` accepts the
+    # full vocabulary (cell, `%`, `c`, `px`, and the keyword forms
+    # `left` / `center` / `right`). When `x` is a keyword, the slot's
+    # effective starting column is computed against `width` AND the
+    # alignment used for blocks routed into the slot is derived from
+    # the same keyword (`x: center` → block align: center, slot
+    # positioned so its centre lands on the slide's centre).
+    #
+    # `size` / `family` / `color` are per-slot text-style overrides:
+    # `size` sets the base scale for h1 and paragraphs (accepts the
+    # same names as inline `<size>`); `family` and `color` cascade
+    # through render_segments_scaled to every text run in the slot.
+    # Inline tags (`<size>`, `<font>`, `<color>`) still win
+    # per-segment.
+    Slot = Struct.new(:name, :x, :y, :width, :height, :size, :family, :color)
+
+    attr_reader :colors, :font, :bullet, :background, :title, :counter, :code, :layouts, :transition, :fragment
 
     def self.load(path)
       raise ArgumentError, "Theme file not found: #{path}" unless File.exist?(path)
@@ -19,11 +38,30 @@ module Przn
         bullet: defaults[:bullet].merge(overrides[:bullet] || {}),
         background: defaults[:background].merge(overrides[:background] || {}),
         title: defaults[:title].merge(overrides[:title] || {}),
-        # `rabbit` is opt-in: absent → nil → renderer uses the plain N/M footer.
-        # Present (even as an empty block) → hash → renderer uses the runner bar.
-        rabbit: defaults[:rabbit] || overrides[:rabbit] ?
-          (defaults[:rabbit] || {}).merge(overrides[:rabbit] || {}) :
-          nil
+        # `code` styles fenced code blocks (family / size / color / bg).
+        # Unset keys fall through to: family → font.family, size →
+        # body_scale, color → terminal default fg, bg → the legacy dim
+        # gray ANSI 236.
+        code: defaults[:code].merge(overrides[:code] || {}),
+        # `counter` is always a hash; empty by default. `counter.duration`
+        # opts into the 🐇 runner bar; without it the renderer shows the
+        # plain " N / M " footer. `counter.color` styles both modes.
+        counter: defaults[:counter].merge(overrides[:counter] || {}),
+        # `transition` carries the slide-fade `duration:` (ms) used when
+        # a slide opts in via `# Title {transition=fade}`. Empty by
+        # default — the renderer's fallback duration kicks in.
+        transition: defaults[:transition].merge(overrides[:transition] || {}),
+        # `fragment` carries the per-fragment animation `duration:` (ms)
+        # used by `<at fragment="fade-up">` and friends. Empty hash if the
+        # user opts out entirely; the renderer falls back to its hardcoded
+        # 300ms when the key is missing.
+        fragment: defaults[:fragment].merge(overrides[:fragment] || {}),
+        # Layouts: per-name replacement (no deep merge across slot lists —
+        # an override redefines that layout's slot list end-to-end). The
+        # name `default` is special: when a slide has no `{layout=...}`
+        # IAL the renderer looks it up here. Themes that don't define
+        # `layouts.default` keep the legacy flow behavior.
+        layouts: defaults[:layouts].merge(overrides[:layouts] || {})
       }
       new(merged)
     end
@@ -71,20 +109,57 @@ module Przn
         bullet: (data[:bullet] || {}).compact,
         background: (data[:background] || {}).compact,
         title: (data[:title] || {}).compact,
-        # nil when the `rabbit:` key isn't in the YAML at all (opt-in feature);
-        # empty hash when it's present but childless.
-        rabbit: data.key?(:rabbit) ? (data[:rabbit] || {}).compact : nil
+        code: (data[:code] || {}).compact,
+        counter: (data[:counter] || {}).compact,
+        transition: (data[:transition] || {}).compact,
+        fragment: (data[:fragment] || {}).compact,
+        layouts: parse_layouts(data[:layouts])
       }
     end
     private_class_method :load_yaml
 
+    # Turn the raw `layouts:` YAML into a `{name => [Slot, ...]}` map.
+    # Each layout's value is just the ordered slot list (no enclosing
+    # `slots:` key in v1 since there's no other per-layout metadata
+    # — promoting to a hash later is a one-line shape change).
+    def self.parse_layouts(raw)
+      return {} unless raw.is_a?(Hash)
+
+      raw.each_with_object({}) do |(name, slot_list), out|
+        next unless slot_list.is_a?(Array)
+        out[name.to_s] = slot_list.map { |s|
+          h = s.transform_keys(&:to_sym)
+          # Back-compat: a legacy `align: center` (etc.) on a slot
+          # used to be a separate knob from `x:`. The two were always
+          # used together in practice — every built-in layout that
+          # set `align:` paired it with an `x:` whose only job was
+          # to leave room for the centred content. The new shape
+          # collapses them into `x: <keyword>`, so an old `align:`
+          # value overrides any numeric `x:` written alongside it.
+          x = h[:align] ? h[:align].to_s : h[:x].to_s
+          Slot.new(
+            h[:name].to_s,
+            x, h[:y].to_s, h[:width].to_s, h[:height].to_s,
+            h[:size]&.to_s,
+            h[:family]&.to_s,
+            h[:color]&.to_s
+          )
+        }
+      end
+    end
+    private_class_method :parse_layouts
+
     def initialize(config)
       @colors = config[:colors]
       @font = config[:font]
       @bullet = config[:bullet]
       @background = config[:background]
       @title = config[:title]
-      @rabbit = config[:rabbit]
+      @code = config[:code] || {}
+      @counter = config[:counter] || {}
+      @transition = config[:transition] || {}
+      @fragment = config[:fragment] || {}
+      @layouts = config[:layouts] || {}
     end
   end
 end

data/lib/przn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Przn
-  VERSION = '0.4.0'
+  VERSION = '0.6.0'
 end

data/lib/przn.rb

@@ -7,6 +7,8 @@ require_relative 'przn/version'
 require_relative 'przn/kitty_text'
 require_relative 'przn/image_util'
 require_relative 'przn/parser'
+require_relative 'przn/code_highlighter'
+require_relative 'przn/mermaid_renderer'
 require_relative 'przn/slide'
 require_relative 'przn/presentation'
 require_relative 'przn/terminal'
@@ -14,6 +16,7 @@ require_relative 'przn/renderer'
 require_relative 'przn/presenter_renderer'
 require_relative 'przn/audience_link'
 require_relative 'przn/echoes_client'
+require_relative 'przn/file_watcher'
 require_relative 'przn/controller'
 require_relative 'przn/screenshot_pdf_exporter'
 require_relative 'przn/theme'
@@ -21,14 +24,15 @@ require_relative 'przn/theme'
 module Przn
   class Error < StandardError; end
 
-  def self.start(file, theme: nil, start_at: nil)
+  def self.start(file, theme: nil, theme_path: nil, start_at: nil, watch: true)
     markdown = File.read(file)
     presentation = Parser.parse(markdown)
     presentation.go_to(start_at - 1) if start_at
     terminal = Terminal.new
     base_dir = File.dirname(File.expand_path(file))
-    renderer = Renderer.new(terminal, base_dir: base_dir, theme: theme)
-    Controller.new(presentation, terminal, renderer)
+    renderer = Renderer.new(terminal, base_dir: base_dir, theme: theme, presentation: presentation)
+    Controller.new(presentation, terminal, renderer,
+                   source_file: file, theme_path: theme_path, watch: watch)
   end
 
   # Audience-side entry: opens the file, listens on `socket`, and renders
@@ -39,7 +43,7 @@ module Przn
     presentation = Parser.parse(markdown)
     terminal = Terminal.new
     base_dir = File.dirname(File.expand_path(file))
-    renderer = Renderer.new(terminal, base_dir: base_dir, theme: theme, mode: :audience)
+    renderer = Renderer.new(terminal, base_dir: base_dir, theme: theme, mode: :audience, presentation: presentation)
 
     terminal.enter_alt_screen
     terminal.hide_cursor
@@ -59,6 +63,7 @@ module Przn
       end
     ensure
       terminal.write "\e]7772;bg-clear\a"
+      terminal.write ImageUtil.kitty_clear_all if ImageUtil.kitty_terminal?
       terminal.show_cursor
       terminal.leave_alt_screen
     end
@@ -97,6 +102,7 @@ module Przn
     terminal = Terminal.new
     base_dir = File.dirname(File.expand_path(file))
     renderer = PresenterRenderer.new(terminal, presentation: presentation, base_dir: base_dir, theme: theme)
-    Controller.new(presentation, terminal, renderer, audience_link: link)
+    Controller.new(presentation, terminal, renderer, audience_link: link,
+                   source_file: file, theme_path: theme_path)
   end
 end

data/sample/ruby-logo-LICENSE

@@ -0,0 +1,15 @@
+The Ruby Logo is Copyright (c) 2006, Yukihiro Matsumoto. It is licensed
+under the terms of the Creative Commons Attribution-ShareAlike 2.5
+agreement:
+
+http://creativecommons.org/licenses/by-sa/2.5/
+
+We ask that you do not use the logo to represent something other than
+the Ruby Programming language. If you have questions about the logo,
+please join the VIT-Discuss mailing list and ask your questions there:
+
+http://rubyforge.org/mailman/listinfo/vit-discuss/
+
+Thank you,
+
+The Ruby Visual Identity Team