przn 0.1.5

data/lib/przn/pdf_exporter.rb

@@ -0,0 +1,546 @@
+# frozen_string_literal: true
+
+# Patch Prawn's line wrapping to break at CJK character boundaries.
+# Prawn's default scan_pattern only breaks at spaces and hyphens,
+# which prevents wrapping for languages like Japanese that have no word spaces.
+module PrawnCJKLineWrap
+  private
+
+  CJK_CHARS = "\u3000-\u9FFF\uF900-\uFAFF\uFF01-\uFF60"
+
+  def scan_pattern(encoding = ::Encoding::UTF_8)
+    ebc = break_chars(encoding)
+    eshy = soft_hyphen(encoding)
+    ehy = hyphen(encoding)
+    ews = whitespace(encoding)
+
+    patterns = [
+      "[^#{CJK_CHARS}#{ebc}]+#{eshy}",
+      "[^#{CJK_CHARS}#{ebc}]+#{ehy}+",
+      "[^#{CJK_CHARS}#{ebc}]+",
+      "[#{CJK_CHARS}]",
+      "[#{ews}]+",
+      "#{ehy}+[^#{ebc}]*",
+      eshy.to_s,
+    ]
+
+    pattern = patterns
+      .map { |p| p.encode(encoding) }
+      .join('|')
+
+    Regexp.new(pattern)
+  end
+end
+
+module Przn
+  class PdfExporter
+    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,
+    }.freeze
+
+    DEFAULT_SCALE = Renderer::DEFAULT_SCALE
+
+    COLOR_MAP = {
+      'red' => 'FF5555', 'green' => '50FA7B', 'yellow' => 'F1FA8C', 'blue' => '6272A4',
+      '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',
+    }.freeze
+
+    def initialize(presentation, base_dir: '.', theme: nil)
+      @presentation = presentation
+      @base_dir = base_dir
+      @theme = theme || Theme.default
+      @bg_color = @theme.colors[:background]
+      @fg_color = @theme.colors[:foreground]
+      @code_bg = @theme.colors[:code_bg]
+      @dim_color = @theme.colors[:dim]
+      @inline_code_color = @theme.colors[:inline_code]
+      @heading_color = @theme.colors[:heading] || @fg_color
+      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 }
+    end
+
+    # Fallback font paths when fc-match is not available.
+    # Prawn's ttfunk requires TrueType outlines (glyf table), not CFF-based fonts.
+    FONT_SEARCH_PATHS = [
+      -> { File.join(Dir.home, 'Library/Fonts/NotoSansJP-Regular.ttf') },
+      -> { Dir.glob('/usr/share/fonts/**/NotoSansCJK-Regular.ttc').first },
+      -> { 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' },
+    ].freeze
+
+    FALLBACK_FONT_FAMILIES = %w[NotoSansCJK NotoSansJP HackGen].freeze
+
+    def export(output_path)
+      require 'prawn'
+      Prawn::Text::Formatted::LineWrap.prepend(PrawnCJKLineWrap) unless Prawn::Text::Formatted::LineWrap < PrawnCJKLineWrap
+
+      pdf = Prawn::Document.new(
+        page_size: [PAGE_WIDTH, PAGE_HEIGHT],
+        margin: 0,
+      )
+
+      register_fonts(pdf)
+
+      @presentation.slides.each_with_index do |slide, si|
+        pdf.start_new_page unless si == 0
+        render_slide(pdf, slide, si)
+      end
+
+      pdf.render_file(output_path)
+    end
+
+    private
+
+    def register_fonts(pdf)
+      font_path, family = find_font
+      return unless font_path
+
+      if font_path.end_with?('.ttc')
+        pdf.font_families.update(
+          '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},
+          }
+        )
+      else
+        bold_path = find_bold_font(font_path, family)
+        pdf.font_families.update(
+          'CJK' => {
+            normal: font_path,
+            bold:   bold_path,
+            italic: font_path,
+          }
+        )
+      end
+
+      pdf.font 'CJK'
+      @font_registered = true
+
+      register_emoji_fallback(pdf, font_path)
+    end
+
+    def find_font
+      family = @theme.font[:family]
+
+      if family
+        path = fc_find(family)
+        return [path, family] if path
+      end
+
+      FALLBACK_FONT_FAMILIES.each do |name|
+        path = fc_find(name)
+        return [path, name] if path
+      end
+
+      FONT_SEARCH_PATHS.each do |finder|
+        path = finder.call
+        return [path, nil] if path && File.exist?(path)
+      end
+      [nil, nil]
+    end
+
+    def find_bold_font(normal_path, family)
+      if family
+        path = fc_find(family, style: 'Bold')
+        return path if path
+      end
+
+      bold_path = normal_path.sub(/Regular|Medium/, 'Bold').sub(/-[^-]*\./, '-Bold.')
+      File.exist?(bold_path) ? bold_path : normal_path
+    end
+
+    def register_emoji_fallback(pdf, primary_font_path)
+      emoji_path = find_emoji_font
+      return unless emoji_path
+      return if emoji_path == primary_font_path
+
+      pdf.font_families.update(
+        'Emoji' => { normal: emoji_path, bold: emoji_path, italic: emoji_path }
+      )
+      pdf.fallback_fonts = ['Emoji']
+    rescue
+      nil
+    end
+
+    EMOJI_FONT_FAMILIES = ['Noto Emoji'].freeze
+
+    def find_emoji_font
+      EMOJI_FONT_FAMILIES.each do |name|
+        path = fc_find(name)
+        next unless path
+        # 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
+        next
+      end
+      nil
+    end
+
+    # Find a font file by family name using fc-list.
+    # fc-list does exact family matching (unlike fc-match which always returns something).
+    # We parse fc-list output directly to get the file path, preferring the requested style.
+    def fc_find(family, style: nil)
+      output = IO.popen(['fc-list', family, '--format=%{file}\n'], &:read)&.strip
+      return nil if output.nil? || output.empty?
+
+      paths = output.lines.map(&:strip).uniq.select { |p| p.end_with?('.ttf', '.ttc') && File.exist?(p) }
+      return nil if paths.empty?
+
+      # Prefer the path whose filename matches the requested style (default: Regular)
+      keyword = style || 'Regular'
+      paths.find { |p| File.basename(p) =~ /[-_]#{keyword}\b/i } || paths.first
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def render_slide(pdf, slide, slide_index)
+      draw_background(pdf)
+
+      margin_x = PAGE_WIDTH / 16.0
+      content_width = PAGE_WIDTH - margin_x * 2
+
+      if slide_index == 0
+        # Title slide: vertically center
+        total_h = estimate_slide_height(slide, content_width, pdf)
+        y = (PAGE_HEIGHT + total_h) / 2.0
+      else
+        y = PAGE_HEIGHT - 20
+      end
+
+      pending_align = nil
+      slide.blocks.each do |block|
+        if block[:type] == :align
+          pending_align = block[:align]
+        else
+          y = render_block(pdf, block, margin_x, content_width, y, align: pending_align)
+          pending_align = nil
+        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
+    end
+
+    def draw_background(pdf)
+      pdf.canvas do
+        pdf.fill_color @bg_color
+        pdf.fill_rectangle [0, PAGE_HEIGHT], PAGE_WIDTH, PAGE_HEIGHT
+      end
+      pdf.fill_color @fg_color
+    end
+
+    def render_block(pdf, block, margin_x, content_width, y, align: nil)
+      case block[:type]
+      when :heading         then render_heading(pdf, block, margin_x, content_width, y)
+      when :paragraph       then render_paragraph(pdf, block, margin_x, content_width, y, align: align)
+      when :code_block      then render_code_block(pdf, block, margin_x, content_width, y)
+      when :unordered_list  then render_unordered_list(pdf, block, margin_x, content_width, y)
+      when :ordered_list    then render_ordered_list(pdf, block, margin_x, content_width, y)
+      when :definition_list then render_definition_list(pdf, block, margin_x, content_width, y)
+      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 :blank           then y - @scale_to_pt[DEFAULT_SCALE]
+      else y - @scale_to_pt[DEFAULT_SCALE]
+      end
+    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]) }
+        h = render_formatted(pdf, formatted, at: [margin_x, y], width: content_width, align: :center)
+        y - h - heading_margin(pt)
+      else
+        pt = @scale_to_pt[DEFAULT_SCALE]
+        prefix = [{text: bullet, size: pt, color: @heading_color, styles: [:bold]}]
+        formatted = prefix + build_formatted_text(text, pt)
+        h = render_formatted(pdf, formatted, at: [margin_x, y], width: content_width)
+        y - h - 4
+      end
+    end
+
+    def render_paragraph(pdf, block, margin_x, content_width, y, align: nil)
+      text = block[:content]
+      scale = max_inline_scale(text) || DEFAULT_SCALE
+      pt = @scale_to_pt[scale]
+      formatted = build_formatted_text(text, pt)
+      align_sym = align || :left
+
+      h = render_formatted(pdf, formatted, at: [margin_x, y], width: content_width, align: align_sym)
+      y - h - 2
+    end
+
+    def render_code_block(pdf, block, margin_x, content_width, y)
+      code_lines = block[:content].lines.map(&:chomp)
+      return y - @scale_to_pt[DEFAULT_SCALE] if code_lines.empty?
+
+      pt = @scale_to_pt[DEFAULT_SCALE] * 0.7
+      line_height = pt * 1.4
+      padding = 8
+      box_height = code_lines.size * line_height + padding * 2
+
+      # Draw background
+      pdf.fill_color @code_bg
+      pdf.fill_rounded_rectangle [margin_x, y], content_width, box_height, 4
+      pdf.fill_color @fg_color
+
+      code_y = y - padding
+      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
+        code_y -= line_height
+      end
+
+      y - box_height - 6
+    end
+
+    def render_unordered_list(pdf, block, margin_x, content_width, y)
+      pt = @scale_to_pt[DEFAULT_SCALE]
+      block[:items].each do |item|
+        depth = item[:depth] || 0
+        indent = depth * pt
+        prefix = [{text: bullet, size: pt, color: @fg_color}]
+        formatted = prefix + build_formatted_text(item[:text], pt)
+        h = render_formatted(pdf, formatted, at: [margin_x + indent, y], width: content_width - indent)
+        y -= h + 6
+      end
+      y
+    end
+
+    def render_ordered_list(pdf, block, margin_x, content_width, y)
+      pt = @scale_to_pt[DEFAULT_SCALE]
+      block[:items].each_with_index do |item, i|
+        depth = item[:depth] || 0
+        indent = depth * pt
+        prefix = [{text: "#{i + 1}. ", size: pt, color: @fg_color}]
+        formatted = prefix + build_formatted_text(item[:text], pt)
+        h = render_formatted(pdf, formatted, at: [margin_x + indent, y], width: content_width - indent)
+        y -= h + 6
+      end
+      y
+    end
+
+    def render_definition_list(pdf, block, margin_x, content_width, y)
+      pt = @scale_to_pt[DEFAULT_SCALE]
+
+      # Term (bold)
+      formatted = build_formatted_text(block[:term], pt).map { |f| f.merge(styles: (f[:styles] || []) | [:bold]) }
+      h = render_formatted(pdf, formatted, at: [margin_x, y], width: content_width)
+      y -= h + 2
+
+      # Definition (indented)
+      indent = pt * 1.5
+      block[:definition].each_line do |line|
+        formatted = build_formatted_text(line.chomp, pt)
+        h = render_formatted(pdf, formatted, at: [margin_x + indent, y], width: content_width - indent)
+        y -= h + 2
+      end
+      y - 4
+    end
+
+    def render_blockquote(pdf, block, margin_x, content_width, y)
+      pt = @scale_to_pt[DEFAULT_SCALE]
+      indent = pt
+
+      block[:content].each_line do |line|
+        formatted = build_formatted_text(line.chomp, pt).map { |f| f.merge(color: @dim_color) }
+        h = render_formatted(pdf, formatted, at: [margin_x + indent, y], width: content_width - indent)
+
+        # Draw pipe
+        pdf.fill_color @dim_color
+        pdf.fill_rectangle [margin_x, y], 2, h
+        pdf.fill_color @fg_color
+
+        y -= h + 2
+      end
+      y - 4
+    end
+
+    def render_table(pdf, block, margin_x, content_width, y)
+      pt = @scale_to_pt[DEFAULT_SCALE] * 0.8
+      row_height = pt * 1.6
+      all_rows = [block[:header]] + block[:rows]
+      num_cols = block[:header]&.size || 0
+      return y if num_cols == 0
+
+      col_width = content_width / num_cols.to_f
+
+      all_rows.each_with_index do |cells, ri|
+        next unless cells
+
+        cells.each_with_index do |cell, ci|
+          x = margin_x + ci * col_width
+          styles = ri == 0 ? [:bold] : []
+          pdf.formatted_text_box [{text: cell, size: pt, color: @fg_color, styles: styles}],
+            at: [x + 4, y], width: col_width - 8, height: row_height, overflow: :shrink_to_fit
+        end
+        y -= row_height
+
+        # Separator after header
+        if ri == 0
+          pdf.stroke_color @dim_color
+          pdf.line_width 0.5
+          pdf.stroke_horizontal_line margin_x, margin_x + content_width, at: y + row_height * 0.3
+          pdf.stroke_color @fg_color
+        end
+      end
+      y - 4
+    end
+
+    def render_image(pdf, block, margin_x, content_width, y)
+      path = resolve_image_path(block[:path])
+      return y - @scale_to_pt[DEFAULT_SCALE] unless File.exist?(path)
+
+      begin
+        max_h = PAGE_HEIGHT * 0.6
+        if (rh = block[:attrs]['relative_height'])
+          max_h = PAGE_HEIGHT * rh.to_i / 100.0
+        end
+
+        img_size = ImageUtil.image_size(path)
+        return y - @scale_to_pt[DEFAULT_SCALE] unless img_size
+
+        img_w, img_h = img_size
+        scale = [content_width / img_w.to_f, max_h / img_h.to_f, 1.0].min
+        display_w = img_w * scale
+        display_h = img_h * scale
+        img_x = margin_x + (content_width - display_w) / 2.0
+
+        pdf.image path, fit: [content_width, max_h], at: [img_x, y]
+        y - display_h - 6
+      rescue Prawn::Errors::UnsupportedImageType
+        y - @scale_to_pt[DEFAULT_SCALE]
+      end
+    end
+
+    def resolve_image_path(path)
+      return path if File.absolute_path?(path) == path
+      File.expand_path(path, @base_dir)
+    end
+
+    def build_formatted_text(text, default_pt)
+      segments = Parser.parse_inline(text)
+      segments.map { |segment|
+        type = segment[0]
+        content = segment[1]
+
+        case type
+        when :tag
+          tag_name = segment[2]
+          if (scale = Parser::SIZE_SCALES[tag_name])
+            {text: content, size: @scale_to_pt[scale], color: @fg_color}
+          elsif (hex = COLOR_MAP[tag_name])
+            {text: content, size: default_pt, color: hex}
+          elsif tag_name.match?(/\A[0-9a-fA-F]{6}\z/)
+            {text: content, size: default_pt, color: tag_name.upcase}
+          else
+            {text: content, size: default_pt, color: @fg_color}
+          end
+        when :bold
+          {text: content, size: default_pt, color: @fg_color, styles: [:bold]}
+        when :italic
+          {text: content, size: default_pt, color: @fg_color, styles: [:italic]}
+        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}
+        when :note
+          {text: content, size: default_pt * 0.7, color: @dim_color}
+        when :text
+          {text: content, size: default_pt, color: @fg_color}
+        else
+          {text: content.to_s, size: default_pt, color: @fg_color}
+        end
+      }
+    end
+
+    def max_inline_scale(text)
+      max = 0
+      text.scan(/\{::tag\s+name="([^"]+)"\}/) do
+        scale = Parser::SIZE_SCALES[$1]
+        max = scale if scale && scale > max
+      end
+      max > 0 ? max : nil
+    end
+
+    def heading_margin(pt)
+      pt * 0.5
+    end
+
+    def estimate_slide_height(slide, content_width, pdf)
+      h = 0
+      slide.blocks.each do |block|
+        case block[:type]
+        when :heading
+          scale = block[:level] == 1 ? KittyText::HEADING_SCALES[1] : DEFAULT_SCALE
+          h += @scale_to_pt[scale] + (block[:level] == 1 ? heading_margin(@scale_to_pt[scale]) : 4)
+        when :paragraph
+          scale = max_inline_scale(block[:content]) || DEFAULT_SCALE
+          h += @scale_to_pt[scale] + 2
+        when :code_block
+          lines = block[:content].lines.size
+          pt = @scale_to_pt[DEFAULT_SCALE] * 0.7
+          h += lines * pt * 1.4 + 16 + 6
+        when :unordered_list
+          h += block[:items].size * (@scale_to_pt[DEFAULT_SCALE] + 6)
+        when :ordered_list
+          h += block[:items].size * (@scale_to_pt[DEFAULT_SCALE] + 6)
+        when :definition_list
+          pt = @scale_to_pt[DEFAULT_SCALE]
+          h += pt + 2 + block[:definition].lines.size * (pt + 2) + 4
+        when :blockquote
+          pt = @scale_to_pt[DEFAULT_SCALE]
+          h += block[:content].lines.size * (pt + 2) + 4
+        when :table
+          pt = @scale_to_pt[DEFAULT_SCALE] * 0.8
+          rows = (block[:header] ? 1 : 0) + block[:rows].size
+          h += rows * pt * 1.6 + 4
+        when :image
+          h += PAGE_HEIGHT * 0.4
+        when :blank
+          h += @scale_to_pt[DEFAULT_SCALE]
+        when :align
+          # no height
+        else
+          h += @scale_to_pt[DEFAULT_SCALE]
+        end
+      end
+      h
+    end
+
+    # Render formatted text and return actual rendered height
+    def render_formatted(pdf, formatted, at:, width:, align: :left)
+      box = Prawn::Text::Formatted::Box.new(
+        formatted, at: at, width: width, align: align,
+        overflow: :shrink_to_fit, document: pdf
+      )
+      box.render
+      box.height
+    end
+
+    def bullet
+      @font_registered ? "\u30FB" : "-"
+    end
+
+  end
+end

data/lib/przn/presentation.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Przn
+  class Presentation
+    attr_reader :slides, :current
+
+    def initialize(slides)
+      @slides = slides.freeze
+      @current = 0
+    end
+
+    def current_slide = slides[current]
+    def total         = slides.size
+    def first_slide?  = current == 0
+    def last_slide?   = current == total - 1
+
+    def next_slide
+      @current = [current + 1, total - 1].min
+    end
+
+    def prev_slide
+      @current = [current - 1, 0].max
+    end
+
+    def go_to(n)
+      @current = n.clamp(0, total - 1)
+    end
+
+    def first_slide!
+      @current = 0
+    end
+
+    def last_slide!
+      @current = total - 1
+    end
+  end
+end