przn 0.4.0 → 0.6.0

data/default_theme.yml

@@ -5,10 +5,10 @@
 # or pass `--theme path/to/your.yml` to override that.
 # All keys are optional — unspecified values fall back to these defaults.
 
-font:
-  family:               # body text font; terminal: OSC 66 f= (Echoes); PDF: Prawn font (auto-detected if blank)
-  size: 18              # base font size in pt for PDF export
-  color:                # body text color (terminal: ANSI fg, PDF: Prawn fg); named ANSI or 6-digit hex
+font:                   # body text typography (paragraphs, lists, h2–h6, code, tables, …)
+  family:               # font family (terminal: OSC 66 f=, requires Echoes)
+  size:                 # OSC 66 scale: numeric (1–7) or named (xx-small … xxxx-large); default 2 (small)
+  color:                # named ANSI or 6-digit hex; falls back to the terminal's default fg when unset
 
 title:                  # h1 typography (slide titles); each attribute is independent of `font`
   family:               # font family (terminal: OSC 66 f=, requires Echoes)
@@ -18,26 +18,106 @@ title:                  # h1 typography (slide titles); each attribute is indepe
 bullet:                 # unordered-list marker; also h2–h6 heading prefix
   text: "・"            # the glyph
   size:                 # OSC 66 scale (1–7) for the bullet; default = body text's scale
+  color:                # named ANSI or 6-digit hex; falls back to body text color (font.color) when unset
+
+code:                   # fenced code block (and inline `<code>`) typography
+  family:               # font family (terminal: OSC 66 f=, requires Echoes); falls back to font.family
+  size:                 # OSC 66 scale: numeric (1–7) or named (xx-small … xxxx-large); default = body text's scale
+  color:                # fg for all code text — fenced blocks and inline `<code>`; named ANSI or 6-digit hex; falls back to body fg
+  bg:                   # block background (fenced only); named ANSI or 6-digit hex; default = dim gray (ANSI 256-color 236)
+  highlight:            # Rouge theme name for syntax highlighting (e.g. monokai, gruvbox, github.dark, base16.solarized.dark);
+                        # unset = the built-in ANSI palette (picks up the terminal's colour theme — works on light or dark)
 
 # Default slide background, applied when a slide has no <bg .../> directive.
-# Echoes-only (OSC 7772). Use either `color` (solid) or `from`/`to`/`angle`
-# (linear gradient). Both unset = no background override.
+# `color` / `from` / `to` / `angle` use Echoes' OSC 7772 (no-op on other
+# terminals). `image` uses the Kitty Graphics Protocol (works on Kitty,
+# Echoes, Wezterm, Ghostty — PNG only) and wins over `color` / gradient
+# when both are set. All unset = no background override.
 background:
+  image:                # background image path, relative to the deck; PNG only
   color:                # solid color, e.g. "#1a1a2e"
   from:                 # gradient endpoint, e.g. "#1a1a2e"
   to:                   # gradient endpoint, e.g. "#16213e"
   angle:                # gradient angle in degrees (0 = left→right, 90 = bottom→top)
   type:                 # gradient type; defaults to "linear"
 
-colors:
-  code_bg: "313244"
-  dim: "6c7086"
-  inline_code: "a6e3a1"
-
-# Bottom-of-screen progress indicator (a nod to the Rabbit presentation tool).
-# Without this key, przn shows a simple " N / M " counter at the bottom-right.
-# To opt in: uncomment the block. The 🐇 rabbit anchors slide progress between
-# the left (current) and right (total) numbers. Set `duration:` to enable the
-# 🐢 turtle tracking elapsed time against the goal.
-# rabbit:
-#   duration:           # "30m", "1h30m", "1800s", or plain integer seconds
+# Bottom-of-screen slide counter. Without `duration:`, przn shows a
+# plain " N / M " counter at the bottom-right. Set `duration:` to opt
+# into the 🐇 / 🐢 runner bar (a nod to the Rabbit presentation tool):
+# slide-progress (🐇) and elapsed-vs-goal (🐢) anchored between the
+# left (current) and right (total) numbers.
+#
+# `rabbit:` / `turtle:` are the raw escape sequences emitted at the
+# runner positions. The defaults are Echoes-private OSC 7772 multicell
+# frames with `flip=h` so the emojis face right (towards the goal at the
+# right edge); on terminals that don't speak OSC 7772 (plain kitty,
+# wezterm, …) the runner emojis don't render. To stay portable, override
+# with a plain glyph or a standard OSC 66 multicell — at the cost of the
+# flip. The renderer writes the value verbatim; whatever lands here goes
+# straight to the terminal.
+counter:
+  color:                # named ANSI or 6-digit hex; default = dim
+  duration:             # "30m", "1h30m", "1800s", or plain integer seconds; opt in to the runner bar
+  rabbit: "\e]7772;multicell;s=2:flip=h;🐇\a"
+  turtle: "\e]7772;multicell;s=2:flip=h;🐢\a"
+
+# Slide-to-slide fade transition. Opt-in per slide via the h1 IAL —
+# `# Title {transition=fade}`. The slide carrying the attribute fades
+# out when leaving it and fades in when arriving at it; the two halves
+# are independent (slide A → B can fade-out from A and snap into B if
+# only A opts in). `duration:` controls the total ms of one half. The
+# fade only paints text — Kitty-graphics images and shapes stay opaque
+# in v1. Echoes-only (uses OSC 7772 cell-alpha); other terminals snap.
+transition:
+  duration: 200         # ms per fade half — full A→B fade is twice this when both sides opt in
+
+# Fragment animations (`<at fragment="fade-up">`, etc.). `duration:` is
+# the per-fragment animation length in ms — drives the lerp from the
+# fragment's initial offset position + alpha 0 to its declared position
+# + alpha 1. Same OSC 7772 cell-alpha plumbing as `<action opacity>`;
+# the x/y move uses the existing action interpolation so non-Echoes
+# terminals still see the slide-in even when the fade portion snaps.
+fragment:
+  duration: 300         # ms per fragment animation
+
+# Slide layouts. Each layout names an ordered list of slots; a slot is a
+# rectangular region with x / y / width / height (1-based cells, or N%
+# of the terminal width/height). A slide picks a layout via an h1 IAL,
+# e.g. `# Title {layout=two-column}`. The `title` slot, when present,
+# is auto-filled from the h1; other slots fill in declaration order,
+# advanced by a `<slot/>` (or `<slot name="..."/>`) marker.
+#
+# Two layouts have special semantics:
+#   `default` — theme-wide fallback for slides without an
+#               `{layout=...}` IAL. Shipped identical to
+#               `title-content`: centered title band across the top,
+#               content below. Override it in your own theme to give
+#               every plain slide a different layout.
+#   `cover`   — automatic for slide 0 when no IAL is set, roughly
+#               emulating Keynote's "Title" slide: big centered
+#               heading near the middle, smaller subtitle near the
+#               bottom. Override / delete from your own theme to opt
+#               out — explicit `{layout=...}` on slide 0 still wins.
+# Other named layouts are opt-in via `# Title {layout=name}`.
+layouts:
+  default:
+    - {name: title,   x: center, y: 3,  width: 90%,  height: 6}
+    - {name: content, x: 5,      y: 10, width: 90%,  height: 80%}
+  cover:
+    - {name: title,    x: center, y: 35%, width: 100%, height: 25%, size: xxx-large}
+    - {name: subtitle, x: center, y: 80%, width: 100%, height: 15%}
+  title-only:
+    - {name: title, x: center, y: 40%, width: 90%,  height: 20%}
+  takahashi:
+    - {name: title, x: center, y: center, width: 100%, height: 100%, size: xxxx-large}
+  title-content:
+    - {name: title,   x: center, y: 3,  width: 90%, height: 6}
+    - {name: content, x: 5,      y: 10, width: 90%, height: 80%}
+  two-column:
+    - {name: title, x: center, y: 3,  width: 90%, height: 6}
+    - {name: left,  x: 5,      y: 10, width: 45%, height: 80%}
+    - {name: right, x: 50%,    y: 10, width: 45%, height: 80%}
+  photo-caption:
+    - {name: title,   x: center, y: 3,  width: 90%, height: 6}
+    - {name: image,   x: 5,      y: 10, width: 60%, height: 70%}
+    - {name: caption, x: 65%,    y: 10, width: 30%, height: 70%}

data/exe/przn

@@ -17,11 +17,16 @@ OptionParser.new do |opts|
     end
   }
   opts.on('-o', '--output FILE', 'Output file path for export') { |v| options[:output] = v }
+  opts.on('--pdf-quality LEVEL',
+          'PDF size/quality preset for --export pdf: lossless|low|medium|high|max (default: medium)') { |v|
+    options[:pdf_quality] = v
+  }
   opts.on('--theme FILE', 'Theme file (YAML)') { |v| options[:theme] = v }
   opts.on('--generate-theme', 'Generate theme.yml in current directory') { options[:generate_theme] = true }
   opts.on('--present', 'Open the deck in presenter mode (auto-spawns an audience window on the secondary display)') { options[:present] = true }
   opts.on('--audience', 'Run as the audience receiver (spawned by --present; expects --socket)') { options[:audience] = true }
   opts.on('--socket PATH', 'Unix socket path used by --present/--audience to coordinate') { |v| options[:socket] = v }
+  opts.on('--no-watch', 'Disable hot reload (default on; auto-reloads the deck and theme.yml when they change on disk)') { options[:watch] = false }
 end.parse!
 
 if options[:generate_theme]
@@ -56,7 +61,7 @@ when 'pdf'
   require_relative '../lib/przn/screenshot_pdf_exporter'
 
   output = options[:output] || File.basename(file, File.extname(file)) + '.pdf'
-  Przn.export_pdf(file, output, theme: theme)
+  Przn.export_pdf(file, output, theme: theme, quality: options[:pdf_quality])
 when 'prawn'
   require_relative '../lib/przn/prawn_pdf_exporter'
 
@@ -72,6 +77,7 @@ else
   elsif options[:present]
     Przn.present(file, theme: theme, theme_path: options[:theme]).run
   else
-    Przn.start(file, theme: theme, start_at: start_at).run
+    Przn.start(file, theme: theme, theme_path: options[:theme], start_at: start_at,
+               watch: options.fetch(:watch, true)).run
   end
 end

data/lib/przn/audience_link.rb

@@ -21,7 +21,7 @@ module Przn
       File.unlink(path) if File.exist?(path)
       server = UNIXServer.new(path)
       client = server.accept
-      send(client, {type: "ready"})
+      send_message(client, {type: "ready"})
       while (line = client.gets)
         msg = JSON.parse(line.chomp, symbolize_names: true)
         break if msg[:type] == "quit"
@@ -36,13 +36,13 @@ module Przn
     end
 
     # Presenter-side: connect to an audience socket at `path` and return a
-    # client object that responds to `#send` and `#close`. Caller drives the
+    # UNIXSocket to hand to `send_message` and `#close`. Caller drives the
     # protocol from the controller.
     def connect(path)
       UNIXSocket.new(path)
     end
 
-    def send(io, msg)
+    def send_message(io, msg)
       io.puts(JSON.generate(msg))
     rescue Errno::EPIPE, IOError
       # Other side hung up — caller decides whether to keep going.

data/lib/przn/code_highlighter.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Przn
+  # Tokenizer wrapper around Rouge for fenced code blocks. Maps Rouge's
+  # token tree to either a hand-tuned ANSI-name palette (the default —
+  # picks up the user's terminal colour theme so code reads naturally
+  # against light or dark backgrounds), or to a named Rouge theme like
+  # `monokai` / `gruvbox` / `github.dark` whose styles return absolute
+  # `#RRGGBB` colours. The choice rides on `theme.code.highlight` in
+  # theme.yml; unset keeps the ANSI palette.
+  module CodeHighlighter
+    # Rouge is required lazily so a `require 'przn'` doesn't pull in
+    # the full 200-language lexer tree at startup for decks that don't
+    # use fenced code blocks at all.
+    @loaded = false
+
+    # Memoized tokenization keyed by `[code, language]`. Warmed in the
+    # background by `Renderer#preload` so that by the time the user
+    # navigates to a slide, its fenced blocks are already tokenized —
+    # the first visit is now as fast as the second. Cache entries are
+    # small (a few KB per block) and never invalidated; the keys
+    # change automatically when slide content changes.
+    @cache = {}
+    @cache_mutex = Mutex.new
+
+    # Memoised Rouge::Theme instances keyed by name. `Rouge::Theme.find`
+    # is cheap but `.new` allocates per call; one instance per theme is
+    # plenty since `style_for` is pure. Returns nil for unknown names —
+    # caller falls through to TOKEN_COLORS, matching the same
+    # silent-fallback philosophy as an unknown lexer.
+    @rouge_theme_cache = {}
+    @rouge_theme_mutex = Mutex.new
+
+    # Mapping from Rouge token qualnames to ANSI color names (resolved
+    # through Parser::NAMED_COLORS by the renderer's `color_code`).
+    # Lookups walk up the dotted hierarchy — `Literal.String.Single`
+    # falls back to `Literal.String`, then `Literal`, before giving up.
+    TOKEN_COLORS = {
+      'Keyword'                    => 'cyan',
+      'Keyword.Constant'           => 'magenta',
+      'Keyword.Declaration'        => 'cyan',
+      'Keyword.Namespace'          => 'cyan',
+      'Keyword.Pseudo'             => 'cyan',
+      'Keyword.Reserved'           => 'cyan',
+      'Keyword.Type'               => 'yellow',
+      'Name.Builtin'               => 'cyan',
+      'Name.Builtin.Pseudo'        => 'magenta',
+      'Name.Class'                 => 'yellow',
+      'Name.Constant'              => 'yellow',
+      'Name.Decorator'             => 'magenta',
+      'Name.Exception'             => 'yellow',
+      'Name.Function'              => 'green',
+      'Name.Function.Magic'        => 'magenta',
+      'Name.Namespace'             => 'yellow',
+      'Name.Tag'                   => 'cyan',
+      'Name.Variable.Class'        => 'yellow',
+      'Name.Variable.Global'       => 'red',
+      'Name.Variable.Instance'     => 'red',
+      'Literal.String'             => 'green',
+      'Literal.String.Doc'         => 'green',
+      'Literal.String.Symbol'      => 'yellow',
+      'Literal.String.Regex'       => 'magenta',
+      'Literal.String.Escape'      => 'magenta',
+      'Literal.String.Interpol'    => 'yellow',
+      'Literal.Number'             => 'magenta',
+      'Comment'                    => 'bright_black',
+      'Operator'                   => 'red',
+      'Operator.Word'              => 'cyan',
+      # Diff / patch hunks, coloured the way `git diff` does: removed
+      # lines red, added lines green, file headers stand out.
+      'Generic.Deleted'            => 'red',
+      'Generic.Inserted'           => 'green',
+      'Generic.Heading'            => 'yellow',
+      'Generic.Subheading'         => 'cyan'
+    }.freeze
+
+    module_function
+
+    # Tokenize `code` with the Rouge lexer for `language` and return an
+    # array of `[color_or_nil, value_string]` token pairs in source
+    # order. `nil` color means "use the default foreground". Returns
+    # nil if Rouge isn't available, the language is unknown, or
+    # `language` is blank — in any of those cases the renderer falls
+    # back to its plain-text path.
+    #
+    # `theme:` picks the colour mapping. `nil` (the default) walks the
+    # built-in ANSI-name TOKEN_COLORS table. A string like `"monokai"` /
+    # `"gruvbox"` / `"github.dark"` resolves to a Rouge theme and uses
+    # its per-token `#RRGGBB` styles instead. Unknown theme names
+    # silently fall through to TOKEN_COLORS.
+    def highlight(code, language, theme: nil)
+      return nil if code.nil? || language.nil? || language.empty?
+      lang = language.to_s.downcase
+      # Theme rides in the cache key so two themes can coexist for the
+      # same `[code, lang]` without trampling each other.
+      key = [code, lang, theme]
+      cached = @cache_mutex.synchronize { @cache[key] }
+      return cached if cached
+
+      load_rouge
+      return nil unless @loaded
+      lexer = Rouge::Lexer.find(lang)
+      return nil unless lexer
+
+      rouge_theme = theme && resolve_rouge_theme(theme)
+
+      tokens = []
+      lexer.lex(code) { |tok, val| tokens << [color_for(tok, rouge_theme), val] }
+      @cache_mutex.synchronize { @cache[key] = tokens }
+      tokens
+    rescue StandardError
+      # A lexer crash shouldn't kill the slide — fall back to plain.
+      nil
+    end
+
+    # Resolve a Rouge theme name to a memoised theme instance.
+    # `Rouge::Theme.find` returns the theme CLASS (or nil); we `.new`
+    # it once and reuse. Anything Rouge doesn't recognise (typos,
+    # retired names, garbage) returns nil and the caller falls back
+    # to TOKEN_COLORS.
+    def resolve_rouge_theme(name)
+      cached = @rouge_theme_mutex.synchronize { @rouge_theme_cache[name] }
+      return cached if cached
+      return nil if @rouge_theme_mutex.synchronize { @rouge_theme_cache.key?(name) }
+
+      klass = Rouge::Theme.find(name.to_s)
+      instance = klass && klass.new
+      @rouge_theme_mutex.synchronize { @rouge_theme_cache[name] = instance }
+      instance
+    rescue StandardError
+      nil
+    end
+
+    # Resolve a token's colour. With a Rouge theme, ask the theme for
+    # its `style_for(token).fg` — a `#RRGGBB` string or nil. Without
+    # one, walk the qualname up the dotted hierarchy through
+    # TOKEN_COLORS: `Literal.String.Single` → `Literal.String` →
+    # `Literal` → nil. nil means "use the default fg."
+    def color_for(token, rouge_theme = nil)
+      if rouge_theme
+        style = rouge_theme.style_for(token)
+        return style && style.fg
+      end
+
+      name = token.qualname
+      while name && !name.empty?
+        return TOKEN_COLORS[name] if TOKEN_COLORS.key?(name)
+        i = name.rindex('.')
+        return nil unless i
+        name = name[0, i]
+      end
+      nil
+    end
+
+    def load_rouge
+      return if @loaded
+      begin
+        require 'rouge'
+        @loaded = true
+      rescue LoadError
+        @loaded = false
+      end
+    end
+  end
+end