przn 0.3.0 → 0.5.0

data/lib/przn/parser.rb

@@ -14,7 +14,7 @@ module Przn
       'xx-large' => 5,
       'xxx-large' => 6,
       'xxxx-large' => 7,
-      '1' => 1, '2' => 2, '3' => 3, '4' => 4, '5' => 5, '6' => 6, '7' => 7,
+      '1' => 1, '2' => 2, '3' => 3, '4' => 4, '5' => 5, '6' => 6, '7' => 7
     }.freeze
 
     NAMED_COLORS = {
@@ -22,9 +22,18 @@ module Przn
       'magenta' => 35, 'cyan' => 36, 'white' => 37,
       'bright_red' => 91, 'bright_green' => 92, 'bright_yellow' => 93,
       'bright_blue' => 94, 'bright_magenta' => 95, 'bright_cyan' => 96,
-      'bright_white' => 97,
+      'bright_white' => 97
     }.freeze
 
+    # HTML-ish attribute, three accepted value forms:
+    #   key="value"   key='value'   key=bareword
+    # The unquoted token excludes whitespace, `=`, `<`, `>`, `"`, `'` and
+    # backtick, matching the spirit of HTML5's unquoted-attribute grammar.
+    # `/` is intentionally NOT excluded so paths like `src=path/to/file`
+    # work — which means self-closing tags need a space before `/>` when
+    # the last attribute is unquoted (`<img src=foo.png />`).
+    ATTR_RE_SRC = '\w+=(?:"[^"]*"|\'[^\']*\'|[^\s=<>"\'`]+)'
+
     module_function
 
     def parse(markdown)
@@ -35,7 +44,7 @@ module Przn
     # Split on h1 headings (Rabbit-compatible)
     def split_slides(markdown)
       chunks = []
-      current = +""
+      current = +''
       in_fence = false
 
       markdown.each_line do |line|
@@ -79,9 +88,20 @@ module Przn
         # Slide background (Echoes OSC 7772):
         #   <bg color="#..."/>                              — solid (bg-color)
         #   <bg from="#..." to="#..." angle="N"/>           — linear gradient (bg-gradient)
-        when /\A\s*<bg((?:\s+\w+="[^"]+")*)\s*\/>\s*\z/
+        # Attribute values may be double-quoted, single-quoted, or
+        # unquoted (HTML5-ish — see ATTR_RE_SRC).
+        when %r{\A\s*<bg((?:\s+#{ATTR_RE_SRC})*)\s*/>\s*\z}o
           blocks << {type: :bg, attrs: parse_xml_attrs(Regexp.last_match(1))}
 
+        # Absolute-position text:
+        #   <at x="N" y="N">content</at>
+        #   {::at x="N" y="N"}content{:/at}
+        # Content can include inline markup (size, color, font, bold, …).
+        when %r{\A\s*<at((?:\s+#{ATTR_RE_SRC})+)\s*>(.*)</at>\s*\z}o
+          blocks << {type: :at, attrs: parse_xml_attrs(Regexp.last_match(1)), content: Regexp.last_match(2)}
+        when %r{\A\s*\{::at((?:\s+#{ATTR_RE_SRC})+)\}(.*)\{:/at\}\s*\z}o
+          blocks << {type: :at, attrs: parse_xml_attrs(Regexp.last_match(1)), content: Regexp.last_match(2)}
+
         # Fenced code block
         when /\A\s*```(\w*)\s*\z/
           lang = Regexp.last_match(1)
@@ -155,7 +175,7 @@ module Przn
               items << {text: Regexp.last_match(2), depth: depth}
             elsif lines[i].match(/\A {2,}(\S.*)/)
               # Continuation line
-              items.last[:text] << " " << Regexp.last_match(1) if items.last
+              items.last[:text] << ' ' << Regexp.last_match(1) if items.last
             else
               break
             end
@@ -176,6 +196,23 @@ module Przn
           i -= 1
           blocks << {type: :ordered_list, items: items}
 
+        # Image, XML form: <img src="path" alt="..." title="..." {:attrs}/>
+        # Equivalent to the markdown `![alt](src "title"){:attrs}` form below
+        # — emits the same `:image` block so the renderer handles both
+        # identically. `src` is required; all other attributes pass through
+        # to `block[:attrs]` (string-keyed, matching markdown's IAL parse) so
+        # `relative_height`, `width`, etc. work the same way.
+        when %r{\A\s*<img((?:\s+#{ATTR_RE_SRC})+)\s*/>\s*\z}o
+          raw = parse_xml_attrs(Regexp.last_match(1))
+          path = raw.delete(:src)
+          if path
+            alt = raw.delete(:alt).to_s
+            title = raw.delete(:title)
+            attrs = raw.transform_keys(&:to_s)
+            normalize_image_attrs!(attrs)
+            blocks << {type: :image, path: path, alt: alt, title: title, attrs: attrs}
+          end
+
         # Image: ![alt](path "title"){:attrs}
         when /\A!\[([^\]]*)\]\((\S+?)(?:\s+"([^"]*)")?\)(.*)/
           alt = Regexp.last_match(1)
@@ -189,11 +226,12 @@ module Przn
             attr_str = rest.sub(/\A\{:?\s*/, '')
             while !attr_str.include?('}') && (i + 1) < lines.size
               i += 1
-              attr_str << " " << lines[i].strip
+              attr_str << ' ' << lines[i].strip
             end
             attr_str = attr_str.sub(/\}\s*\z/, '')
             parse_image_attrs(attr_str, attrs)
           end
+          normalize_image_attrs!(attrs)
           blocks << {type: :image, path: path, alt: alt, title: title, attrs: attrs}
 
         # Definition list: term on one line, :   definition on next
@@ -237,12 +275,14 @@ module Przn
       attrs.slice(:face, :size, :color)
     end
 
-    # Generic attribute scanner — `key="value"` pairs, returned as a hash with
-    # symbolized keys. Doesn't validate which keys are allowed; callers slice.
+    # Generic attribute scanner — three value forms accepted:
+    #   key="value"   key='value'   key=bareword
+    # Returns a hash with symbolized keys. Doesn't validate which keys
+    # are allowed; callers slice.
     def parse_xml_attrs(str)
       attrs = {}
-      str.scan(/(\w+)="([^"]+)"/) do |key, value|
-        attrs[key.to_sym] = value
+      str.scan(/(\w+)=(?:"([^"]*)"|'([^']*)'|([^\s=<>"'`]+))/) do |key, dq, sq, uq|
+        attrs[key.to_sym] = dq || sq || uq
       end
       attrs
     end
@@ -254,6 +294,22 @@ module Przn
       end
     end
 
+    # Rewrite `height="N%"` / `width="N%"` into the canonical
+    # `relative_height="N"` / `relative_width="N"` the renderer reads.
+    # Values without a `%` suffix pass through unchanged (and are
+    # ignored downstream); an explicit `relative_*` already on the
+    # block wins so authors can mix forms without surprise.
+    def normalize_image_attrs!(attrs)
+      if (h = attrs['height']) && (m = h.match(/\A(\d+)%\z/))
+        attrs.delete('height')
+        attrs['relative_height'] ||= m[1]
+      end
+      if (w = attrs['width']) && (m = w.match(/\A(\d+)%\z/))
+        attrs.delete('width')
+        attrs['relative_width'] ||= m[1]
+      end
+    end
+
     def parse_table(lines)
       rows = []
       lines.each do |line|
@@ -275,22 +331,22 @@ module Przn
           segments << [:tag, scanner[2], scanner[1]]
         elsif scanner.scan(/<size=([^>\s]+)>(.*?)<\/size>/)
           segments << [:tag, scanner[2], scanner[1]]
-        elsif scanner.scan(/<font((?:\s+\w+="[^"]+")+)\s*>(.*?)<\/font>/)
+        elsif scanner.scan(%r{<font((?:\s+#{ATTR_RE_SRC})+)\s*>(.*?)</font>}o)
           segments << [:font, scanner[2], parse_font_attrs(scanner[1])]
-        elsif scanner.scan(/\{::font((?:\s+\w+="[^"]+")+)\}(.*?)\{:\/font\}/)
+        elsif scanner.scan(%r{\{::font((?:\s+#{ATTR_RE_SRC})+)\}(.*?)\{:/font\}}o)
           segments << [:font, scanner[2], parse_font_attrs(scanner[1])]
         elsif scanner.scan(/\{::note\}(.*?)\{:\/note\}/)
           segments << [:note, scanner[1]]
         elsif scanner.scan(/<note>(.*?)<\/note>/)
           segments << [:note, scanner[1]]
-        elsif scanner.scan(/\{::wait\/\}/) || scanner.scan(/<wait\s*\/>/)
+        elsif scanner.scan('{::wait/}') || scanner.scan(/<wait\s*\/>/)
           # skip wait markers in inline text
-        elsif scanner.scan(/&lt;/)
-          segments << [:text, "<"]
-        elsif scanner.scan(/&gt;/)
-          segments << [:text, ">"]
-        elsif scanner.scan(/&amp;/)
-          segments << [:text, "&"]
+        elsif scanner.scan('&lt;')
+          segments << [:text, '<']
+        elsif scanner.scan('&gt;')
+          segments << [:text, '>']
+        elsif scanner.scan('&amp;')
+          segments << [:text, '&']
         elsif scanner.scan(/`([^`]+)`/)
           segments << [:code, scanner[1]]
         elsif scanner.scan(/\*\*(.+?)\*\*/)
@@ -304,7 +360,21 @@ module Przn
         end
       end
 
-      segments
+      # Coalesce adjacent :text segments. The scanner has to bail to a
+      # single-character `.` when it sees `&` so the `&lt;` / `&gt;` /
+      # `&amp;` entity matches can run on the next iteration, which
+      # leaves a bare `&` as its own segment and fragments the
+      # surrounding text. Merging them back together means one OSC 66
+      # multicell sequence per typeset run — important for h1 titles
+      # under a proportional font, where Echoes pads each run
+      # independently and stray segments become visible gaps.
+      segments.each_with_object([]) do |seg, acc|
+        if seg[0] == :text && acc.last && acc.last[0] == :text
+          acc.last[1] = acc.last[1] + seg[1]
+        else
+          acc << seg
+        end
+      end
     end
   end
 end

data/lib/przn/{pdf_exporter.rb → prawn_pdf_exporter.rb}

@@ -24,7 +24,7 @@ module PrawnCJKLineWrap
       "[#{CJK_CHARS}]",
       "[#{ews}]+",
       "#{ehy}+[^#{ebc}]*",
-      eshy.to_s,
+      eshy.to_s
     ]
 
     Regexp.new(patterns.join('|'))
@@ -32,13 +32,25 @@ module PrawnCJKLineWrap
 end
 
 module Przn
-  class PdfExporter
+  # Legacy PDF export via Prawn — renders the deck directly into a vector
+  # PDF without touching the terminal. Diverges from what's on screen for
+  # any feature the live renderer adds (OSC 66 sized text, OSC 7772
+  # backgrounds, proportional fonts) but works headlessly.
+  def self.export_pdf_prawn(file, output, theme: nil)
+    markdown = File.read(file)
+    presentation = Parser.parse(markdown)
+    base_dir = File.dirname(File.expand_path(file))
+    PrawnPdfExporter.new(presentation, base_dir: base_dir, theme: theme).export(output)
+    puts "Generated: #{output}"
+  end
+
+  class PrawnPdfExporter
     PAGE_WIDTH  = 960
     PAGE_HEIGHT = 540
     DEFAULT_FONT_SIZE = 18
     DEFAULT_SCALE_TO_PT = {
       1 => 10, 2 => 18, 3 => 24, 4 => 32,
-      5 => 40, 6 => 48, 7 => 56,
+      5 => 40, 6 => 48, 7 => 56
     }.freeze
 
     DEFAULT_SCALE = Renderer::DEFAULT_SCALE
@@ -48,7 +60,7 @@ module Przn
       'magenta' => 'FF79C6', 'cyan' => '8BE9FD', 'white' => 'F8F8F2',
       'bright_red' => 'FF6E6E', 'bright_green' => '69FF94', 'bright_yellow' => 'FFFFA5',
       'bright_blue' => 'D6ACFF', 'bright_magenta' => 'FF92DF', 'bright_cyan' => 'A4FFFF',
-      'bright_white' => 'FFFFFF',
+      'bright_white' => 'FFFFFF'
     }.freeze
 
     def initialize(presentation, base_dir: '.', theme: nil)
@@ -56,7 +68,7 @@ module Przn
       @base_dir = base_dir
       @theme = theme || Theme.default
       @bg_color = @theme.background && @theme.background[:color]
-      @fg_color = @theme.font[:color] || "000000"
+      @fg_color = @theme.font[:color] || '000000'
       @code_bg = @theme.colors[:code_bg]
       @dim_color = @theme.colors[:dim]
       @inline_code_color = @theme.colors[:inline_code]
@@ -73,7 +85,7 @@ module Przn
       -> { Dir.glob('/usr/share/fonts/**/NotoSansJP-Regular.ttf').first },
       -> { File.join(Dir.home, 'Library/Fonts/HackGen-Regular.ttf') },
       -> { '/Library/Fonts/Arial Unicode.ttf' },
-      -> { '/System/Library/Fonts/Supplemental/Arial Unicode.ttf' },
+      -> { '/System/Library/Fonts/Supplemental/Arial Unicode.ttf' }
     ].freeze
 
     FALLBACK_FONT_FAMILIES = %w[NotoSansCJK NotoSansJP HackGen].freeze
@@ -84,7 +96,7 @@ module Przn
 
       pdf = Prawn::Document.new(
         page_size: [PAGE_WIDTH, PAGE_HEIGHT],
-        margin: 0,
+        margin: 0
       )
 
       register_fonts(pdf)
@@ -108,7 +120,7 @@ module Przn
           'CJK' => {
             normal: {file: font_path, font: 0},
             bold:   {file: font_path.sub('W3', 'W6').then { |p| File.exist?(p) ? p : font_path }, font: 0},
-            italic: {file: font_path, font: 0},
+            italic: {file: font_path, font: 0}
           }
         )
       else
@@ -117,7 +129,7 @@ module Przn
           'CJK' => {
             normal: font_path,
             bold:   bold_path,
-            italic: font_path,
+            italic: font_path
           }
         )
       end
@@ -144,10 +156,10 @@ module Przn
         pdf.font_families.update(family => {
           normal: path,
           bold: bold_path,
-          italic: path,
+          italic: path
         })
         @registered_inline_fonts[family] = true
-      rescue
+      rescue StandardError
         next
       end
     end
@@ -218,7 +230,7 @@ module Przn
         'Emoji' => { normal: emoji_path, bold: emoji_path, italic: emoji_path }
       )
       pdf.fallback_fonts = ['Emoji']
-    rescue
+    rescue StandardError
       nil
     end
 
@@ -231,7 +243,7 @@ module Przn
         # Only use fonts with glyf outlines (not SBIX/COLR bitmap-only fonts)
         ttf = TTFunk::File.open(path)
         return path if ttf.directory.tables.key?('glyf')
-      rescue
+      rescue StandardError
         next
       end
       nil
@@ -609,7 +621,7 @@ module Przn
     end
 
     def bullet
-      @font_registered ? @theme.bullet[:text] : "-"
+      @font_registered ? @theme.bullet[:text] : '-'
     end
 
   end

data/lib/przn/presenter_renderer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Przn
+  # Drives the laptop-side view in extended-display mode. Reuses the existing
+  # Renderer to draw the current slide (notes still rendered dim-inline so the
+  # presenter sees them in context), then overlays a three-line strip at the
+  # bottom of the terminal: speaker notes summary, next-slide preview, and a
+  # 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
+      @started_at = Time.now
+    end
+
+    def render(slide, current:, total:, started_at: nil)
+      super(slide, current: current, total: total, started_at: started_at)
+      @mutex.synchronize { draw_presenter_strip(current, total) }
+    end
+
+    private
+
+    def draw_presenter_strip(current, total)
+      w = @terminal.width
+      h = @terminal.height
+      slide = @presentation.slides[current]
+      notes_text = slide.notes.join(' / ')
+      next_title = current + 1 < total ? preview_title(@presentation.slides[current + 1]) : nil
+      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?
+      notes_row = rabbit_mode ? h - 3 : h - 2
+      next_row  = rabbit_mode ? h - 2 : h - 1
+
+      @terminal.move_to(notes_row, 1)
+      @terminal.write "#{ANSI[:dim]}Notes: #{truncate_to_width(notes_text, [w - 8, 1].max)}#{ANSI[:reset]}"
+      @terminal.move_to(next_row, 1)
+      @terminal.write "#{ANSI[:dim]}Next:  #{truncate_to_width(next_title || '—', [w - 8, 1].max)}#{ANSI[:reset]}"
+
+      unless rabbit_mode
+        @terminal.move_to(h, 1)
+        @terminal.write "#{ANSI[:dim]}#{truncate_to_width(footer, w)}#{ANSI[:reset]}"
+      end
+
+      @terminal.flush
+    end
+
+    def preview_title(slide)
+      return nil unless slide
+      slide.blocks.each do |b|
+        case b[:type]
+        when :heading, :paragraph then return strip_markup(b[:content].to_s)
+        end
+      end
+      nil
+    end
+
+    def format_elapsed(seconds)
+      h = (seconds / 3600).to_i
+      m = ((seconds % 3600) / 60).to_i
+      s = (seconds % 60).to_i
+      format('%02d:%02d:%02d', h, m, s)
+    end
+  end
+end