przn 0.4.0 → 0.6.0

data/lib/przn/prawn_pdf_exporter.rb

@@ -63,18 +63,51 @@ module Przn
       'bright_white' => 'FFFFFF'
     }.freeze
 
+    # Fallback palette used when the theme leaves a colour unset and
+    # no legacy `colors.*` key fills in either. These are hex (no `#`)
+    # so they can flow straight into `pdf.fill_color`.
+    DEFAULT_CODE_BG = '313244'
+    DEFAULT_DIM     = '6c7086'
+
     def initialize(presentation, base_dir: '.', theme: nil)
       @presentation = presentation
       @base_dir = base_dir
       @theme = theme || Theme.default
       @bg_color = @theme.background && @theme.background[:color]
       @fg_color = @theme.font[:color] || '000000'
-      @code_bg = @theme.colors[:code_bg]
-      @dim_color = @theme.colors[:dim]
-      @inline_code_color = @theme.colors[:inline_code]
-      base = (@theme.font[:size] || DEFAULT_FONT_SIZE).to_f
-      ratio = base / DEFAULT_FONT_SIZE
-      @scale_to_pt = DEFAULT_SCALE_TO_PT.transform_values { |v| v * ratio }
+      # Resolve in priority order:
+      #   1. new `theme.code` keys (terminal & PDF share them)
+      #   2. legacy `theme.colors.*` (back-compat for decks that haven't
+      #      migrated yet — accepted on read but no longer documented)
+      #   3. hardcoded default
+      #
+      # The page-number footer reads `counter.color` first so the same
+      # theme key styles the counter in both the terminal and PDF paths.
+      colors = @theme.colors || {}
+      @code_bg = sanitize_hex(@theme.code[:bg]) || colors[:code_bg] || DEFAULT_CODE_BG
+      # `code.color` styles ALL code text — fenced blocks and inline
+      # `<code>` segments alike. Used to be split into two knobs
+      # (`colors.inline_code` for inline only, body fg for fenced)
+      # for no real reason beyond historical defaults.
+      @code_color = sanitize_hex(@theme.code[:color]) || colors[:inline_code] || @fg_color
+      @counter_color = sanitize_hex(@theme.counter[:color]) || colors[:dim] || DEFAULT_DIM
+      @dim_color = colors[:dim] || DEFAULT_DIM
+      # `theme.font.size` is now an OSC 66 scale (1–7), matching
+      # title.size — meaningful to the terminal renderer, not to
+      # this PDF path. Prawn keeps its own fixed point-size table.
+      @scale_to_pt = DEFAULT_SCALE_TO_PT
+    end
+
+    # Reduce a theme colour value to a 6-digit hex string (no `#`) so
+    # Prawn's `fill_color` / `stroke_color` can consume it directly.
+    # The terminal-side resolver accepts CSS / ANSI named colours via
+    # CSS_NAMED_COLORS, but Prawn doesn't have that table — named
+    # values fall through to the legacy `colors.*` back-compat key
+    # and then to the hardcoded default in the PDF path.
+    def sanitize_hex(value)
+      return nil if value.nil?
+      s = value.to_s.strip.sub(/\A#/, '')
+      s.match?(/\A[0-9a-fA-F]{6}\z/) ? s : nil
     end
 
     # Fallback font paths when fc-match is not available.
@@ -290,12 +323,16 @@ module Przn
         end
       end
 
-      # Page number
-      total = @presentation.total
-      status = "#{slide_index + 1} / #{total}"
-      pdf.fill_color @dim_color
-      pdf.text_box status, at: [0, 16], width: PAGE_WIDTH - 10, height: 14, size: 8, align: :right
-      pdf.fill_color @fg_color
+      # Page number — reads `theme.counter.color` like the terminal's
+      # bottom-right counter does, so a single theme key styles both.
+      # Skipped on a `{counter=hide}` slide, as in the terminal.
+      unless slide.attrs[:counter].to_s == 'hide'
+        total = @presentation.total
+        status = "#{slide_index + 1} / #{total}"
+        pdf.fill_color @counter_color
+        pdf.text_box status, at: [0, 16], width: PAGE_WIDTH - 10, height: 14, size: 8, align: :right
+        pdf.fill_color @fg_color
+      end
     end
 
     def draw_background(pdf)
@@ -319,17 +356,98 @@ module Przn
       when :blockquote      then render_blockquote(pdf, block, margin_x, content_width, y)
       when :table           then render_table(pdf, block, margin_x, content_width, y)
       when :image           then render_image(pdf, block, margin_x, content_width, y)
+      when :ref             then render_ref(pdf, block, margin_x, content_width, y, align: align)
+      when :group           then render_group(pdf, block, margin_x, content_width, y, align: align)
       when :blank           then y - @scale_to_pt[DEFAULT_SCALE]
       else y - @scale_to_pt[DEFAULT_SCALE]
       end
     end
 
+    # Walk a `<group>`'s children, threading y through each child's
+    # render. Same atomic-container semantics as the terminal renderer's
+    # render_group: align flows through; waits / actions pass without
+    # advancing y; everything else dispatches to render_block. v1
+    # caveat: positioned children (`<at>`, shapes) inherit the existing
+    # Prawn fallback limitation — neither type is drawn in PDF today.
+    def render_group(pdf, block, margin_x, content_width, y, align: nil)
+      pending_align = align
+      (block[:children] || []).each do |child|
+        case child[:type]
+        when :align  then pending_align = child[:align]
+        when :wait, :action then next
+        else
+          y = render_block(pdf, child, margin_x, content_width, y, align: pending_align)
+          pending_align = nil
+        end
+      end
+      y
+    end
+
+    # Look up the source block by id and re-dispatch through render_block.
+    # Mirrors the terminal renderer's render_ref. PDF parity is partial in
+    # v1: refs to flow blocks (paragraph / list / code / blockquote /
+    # heading / table / image) render; refs to `<at>` or shapes match
+    # the source's existing Prawn limitation (those types aren't drawn
+    # in PDF today regardless).
+    def render_ref(pdf, block, margin_x, content_width, y, align: nil)
+      id = block[:attrs] && (block[:attrs][:id] || block[:attrs]['id'])
+      return y unless id
+      source = @presentation.find_by_id(id)
+      return y unless source
+
+      # Deep-clone the source (so a group source's children don't share
+      # storage with the deck) and strip ids from every descendant —
+      # mirrors the terminal renderer's render_ref semantics.
+      synthetic = deep_clone_strip_ids(source)
+      src_attrs = source[:attrs] || {}
+      merged = synthetic[:attrs]
+      (block[:attrs] || {}).each do |k, v|
+        next if k.to_s == 'id'
+        if src_attrs.key?(k.to_sym)
+          merged[k.to_sym] = v
+        elsif src_attrs.key?(k.to_s)
+          merged[k.to_s] = v
+        elsif k.is_a?(Symbol)
+          merged[k] = v
+        else
+          merged[k.to_s] = v
+        end
+      end
+
+      render_block(pdf, synthetic, margin_x, content_width, y, align: align)
+    end
+
+    # Recursive clone with every node's `id` stripped — same shape as
+    # the terminal renderer's helper. Kept local to the exporter (~10
+    # lines, no shared base class) rather than reaching across module
+    # boundaries.
+    def deep_clone_strip_ids(block)
+      cloned = block.dup
+      attrs = (block[:attrs] || {}).dup
+      attrs.delete(:id)
+      attrs.delete('id')
+      cloned[:attrs] = attrs
+      if block[:children].is_a?(Array)
+        cloned[:children] = block[:children].map { |c| deep_clone_strip_ids(c) }
+      end
+      cloned
+    end
+
     def render_heading(pdf, block, margin_x, content_width, y)
       text = block[:content]
       if block[:level] == 1
         scale = KittyText::HEADING_SCALES[1]
         pt = @scale_to_pt[scale]
-        formatted = build_formatted_text(text, pt).map { |f| f.merge(styles: (f[:styles] || []) | [:bold]) }
+        # h1 spans get the bold heading weight, except spans that are
+        # already italic — Prawn would look up a `bold_italic` variant
+        # which the CJK fallback font doesn't ship, and the heading
+        # would crash. The italic span keeps its emphasis; the rest
+        # of the title stays bold.
+        formatted = build_formatted_text(text, pt).map do |f|
+          styles = f[:styles] || []
+          styles = styles | [:bold] unless styles.include?(:italic)
+          f.merge(styles: styles)
+        end
         h = render_formatted(pdf, formatted, at: [margin_x, y], width: content_width, align: :center)
         y - h - heading_margin(pt)
       else
@@ -370,7 +488,7 @@ module Przn
       code_lines.each do |line|
         # Replace leading spaces with non-breaking spaces to preserve indentation
         preserved = line.sub(/\A +/) { |m| "\u00A0" * m.length }
-        pdf.text_box preserved, at: [margin_x + padding, code_y], width: content_width - padding * 2, height: line_height, size: pt, color: @fg_color, overflow: :shrink_to_fit
+        pdf.text_box preserved, at: [margin_x + padding, code_y], width: content_width - padding * 2, height: line_height, size: pt, color: @code_color, overflow: :shrink_to_fit
         code_y -= line_height
       end
 
@@ -545,7 +663,7 @@ module Przn
         when :strikethrough
           {text: content, size: default_pt, color: @fg_color, styles: [:strikethrough]}
         when :code
-          {text: " #{content} ", size: default_pt * 0.85, color: @inline_code_color}
+          {text: " #{content} ", size: default_pt * 0.85, color: @code_color}
         when :note
           {text: content, size: default_pt * 0.7, color: @dim_color}
         when :text

data/lib/przn/presentation.rb

@@ -33,5 +33,48 @@ module Przn
     def last_slide!
       @current = total - 1
     end
+
+    # Deck-wide lookup for a block declared with `id="..."`. Used by
+    # `<ref id="..."/>` to find the source block on another (or the
+    # same) slide. Returns the source block hash, or nil when no
+    # block with that id is found. First match by slide order wins;
+    # `:ref` blocks themselves are excluded from the index so a chain
+    # of refs doesn't resolve transitively in v1.
+    def find_by_id(id)
+      @by_id ||= build_id_index
+      @by_id[id.to_s]
+    end
+
+    private
+
+    def build_id_index
+      index = {}
+      @slides.each { |slide| walk_blocks(slide.blocks) { |b| record_id(index, b) } }
+      index
+    end
+
+    # Yield every block reachable from `blocks`, descending into
+    # `:group` (or any other) children. Lets the deck-wide index see
+    # ids declared inside composites so `<ref id="inner-x"/>` resolves
+    # to a nested block regardless of which group wraps it.
+    def walk_blocks(blocks, &block)
+      blocks.each do |b|
+        yield b
+        walk_blocks(b[:children], &block) if b[:children].is_a?(Array)
+      end
+    end
+
+    def record_id(index, b)
+      return if b[:type] == :ref
+      a = b[:attrs]
+      return unless a
+      # Parser key style is split: `:at` and shapes keep symbols
+      # from parse_xml_attrs, while `:image` (and any other block
+      # that runs `transform_keys(&:to_s)`) stores string keys.
+      # Check both — same as compute_effective_state's by_id build.
+      bid = a['id'] || a[:id]
+      return unless bid
+      index[bid.to_s] ||= b
+    end
   end
 end

data/lib/przn/presenter_renderer.rb

@@ -8,8 +8,7 @@ module Przn
   # footer with the slide counter + elapsed time.
   class PresenterRenderer < Renderer
     def initialize(terminal, presentation:, base_dir: '.', theme: nil)
-      super(terminal, base_dir: base_dir, theme: theme, mode: :presenter)
-      @presentation = presentation
+      super(terminal, base_dir: base_dir, theme: theme, mode: :presenter, presentation: presentation)
       @started_at = Time.now
     end
 
@@ -29,12 +28,13 @@ module Przn
       elapsed = format_elapsed(Time.now - @started_at)
       footer = "Slide #{current + 1} / #{total}   #{elapsed}"
 
-      # When the theme opts into the rabbit/turtle indicator, the parent
-      # renderer has already drawn it on rows h-1 and h. Lift the strip up
-      # so it doesn't clobber the runner bar; the indicator itself replaces
-      # the strip's own footer line (slide #, elapsed time are visible there
-      # anyway via rabbit position and turtle position).
-      rabbit_mode = !@theme.rabbit.nil?
+      # When `theme.counter.duration` opts into the 🐇 / 🐢 indicator, the
+      # parent renderer has already drawn it on rows h-1 and h. Lift the
+      # strip up so it doesn't clobber the runner bar; the indicator
+      # itself replaces the strip's own footer line (slide #, elapsed
+      # time are visible there anyway via rabbit / turtle position).
+      counter = @theme.counter || {}
+      rabbit_mode = !counter[:duration].nil? && !counter[:duration].to_s.empty?
       notes_row = rabbit_mode ? h - 3 : h - 2
       next_row  = rabbit_mode ? h - 2 : h - 1
 
@@ -61,6 +61,20 @@ module Przn
       nil
     end
 
+    # Flatten inline markup to plain text via the parser's own inline
+    # scanner, so the preview tracks every tag the slide itself renders.
+    # Notes are presenter-strip material, not title text; `<br>` reads
+    # as a space on the one-line strip.
+    def strip_markup(text)
+      Parser.parse_inline(text).filter_map { |type, content|
+        case type
+        when :note then nil
+        when :break then ' '
+        else content
+        end
+      }.join
+    end
+
     def format_elapsed(seconds)
       h = (seconds / 3600).to_i
       m = ((seconds % 3600) / 60).to_i