rapicco 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f75b483f11ab21e49743716cf5c8e41d66d906e59a06a6cd3d91e7a68951f5da
+  data.tar.gz: dfdd6c4403ca2cd7d652b1a4bdf13512919f4142c8e5836279142462583734fa
+SHA512:
+  metadata.gz: 995b0755fb6634c30e0183b51cd7638da3fb1b6ba0f32eb56ddd4df030710fcae9c8da188a4ce698fcd7c80b10657edd6819d3cfd4e84ed093345f1f05a8885f
+  data.tar.gz: f277684e2d09d4446793ccbaffee37175cd2109838006a1d5d95d4c3a41ba510ff802101303975a9307a14208f19c30b6772534af3663639f422c8c5433c3242

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PicoRuby
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# Rapicco
+
+A wrapper tool of PicoRuby Rapicco terminal-based presentation.
+
+## Overview
+
+Rapicco is a tool that shows presentation slide on terminal emulator by running picoruby process.
+It also converts Rapicco presentations  into PDF documents capturing the ANSI terminal output from Rapicco and renders it as a high-quality PDF.
+
+## Requirements
+
+- Ruby 3.0 or later
+- Cairo graphics library
+- PicoRuby with Rapicco installed
+
+## Installation
+
+```bash
+gem install rapicco
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'rapicco'
+```
+
+## Usage
+
+**Show presentation:**
+```bash
+bundle exec rapicco input.md
+```
+
+**Generate PDF:**
+```bash
+bundle exec rapicco --print input.md
+```
+
+## How it generates PDF
+
+1. Executes Rapicco with the input markdown file
+2. Captures each page of the presentation via PTY
+3. Parses ANSI escape sequences (colors, cursor positioning, block characters)
+4. Renders each page to PDF using Cairo graphics library
+5. Combines all pages into a single PDF document
+
+## License
+
+Copyright © 2025 HASUMI Hitoshi. See MIT-LICENSE for further details.

data/bin/rapicco

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/rapicco'
+
+def print_usage
+  puts "Usage: rapicco [command] [options] <slide.md>"
+  puts ""
+  puts "Commands:"
+  puts "  rapicco new <directory>                      Create slide project template"
+  puts "  rapicco new .                                Create template in current directory"
+  puts "  rapicco <slide.md>                           Run presentation"
+  puts "  rapicco --print <slide.md>                   Export to PDF (slide.pdf)"
+  puts "  rapicco -p -o output.pdf <slide.md>          Export to PDF with custom name"
+  puts ""
+  puts "Options:"
+  puts "  -p, --print                  Export presentation to PDF instead of running"
+  puts "  -o, --output-filename FILE   Output PDF filename (default: <slide>.pdf)"
+  puts "  --rapicco-command CMD        Command to run Rapicco (default: use PICORUBY_PATH)"
+  puts "  -h, --help                   Show this help message"
+  puts ""
+  puts "PDF export options:"
+  puts "  --cols NUMBER                Terminal columns for PDF capture (default: 500)"
+  puts "  --rows NUMBER                Terminal rows for PDF capture (default: 280)"
+  puts "  --char-width NUMBER          Character width in pixels (default: 5)"
+  puts "  --char-height NUMBER         Character height in pixels (default: 10)"
+  puts ""
+  puts "Examples:"
+  puts "  rapicco new my-slide"
+  puts "  rapicco new ."
+  puts "  rapicco presentation.md"
+  puts "  rapicco --print presentation.md"
+  puts "  rapicco -p -o output.pdf presentation.md"
+  puts "  rapicco -p --cols 600 --rows 150 presentation.md"
+end
+
+# Check for new command
+if ARGV[0] == 'new'
+  if ARGV.length != 2
+    puts "Error: Please provide a directory name"
+    puts "Usage: rapicco new <directory>"
+    exit 1
+  end
+
+  require_relative '../lib/rapicco/installer'
+  installer = Rapicco::Installer.new(ARGV[1])
+  begin
+    installer.install
+    exit 0
+  rescue => e
+    puts "Error: #{e.message}"
+    exit 1
+  end
+end
+
+options = {}
+args = []
+
+print_mode = false
+
+i = 0
+while i < ARGV.length
+  case ARGV[i]
+  when '-h', '--help'
+    print_usage
+    exit 0
+  when '-p', '--print'
+    print_mode = true
+  when '-o', '--output-filename'
+    options[:output_filename] = ARGV[i + 1]
+    i += 1
+  when '--rapicco-command'
+    options[:rapicco_command] = ARGV[i + 1]
+    i += 1
+  when '--cols'
+    options[:cols] = ARGV[i + 1].to_i
+    i += 1
+  when '--rows'
+    # Rapicco uses half-block characters (2 vertical dots per character)
+    # so divide rows by 2 for internal processing
+    options[:rows] = ARGV[i + 1].to_i / 2
+    i += 1
+  when '--char-width'
+    options[:char_width] = ARGV[i + 1].to_i
+    i += 1
+  when '--char-height'
+    options[:char_height] = ARGV[i + 1].to_i
+    i += 1
+  else
+    args << ARGV[i]
+  end
+  i += 1
+end
+
+if args.length != 1
+  puts "Error: Please provide a slide file"
+  puts ""
+  print_usage
+  exit 1
+end
+
+slide_file = args[0]
+
+unless File.exist?(slide_file)
+  puts "Error: Input file not found: #{slide_file}"
+  exit 1
+end
+
+if print_mode
+  # PDF export mode
+  output_pdf = options[:output_filename] || slide_file.sub(/\.[^.]+$/, '.pdf')
+
+  # Auto-calculate missing dimension for 16:9 aspect ratio
+  if options[:cols] && !options[:rows]
+    # cols specified, calculate rows for 16:9
+    # Divide by 2 because Rapicco uses half-block characters (2 vertical dots per character)
+    options[:rows] = (options[:cols] * 9.0 / 16.0 / 2.0).round
+  elsif !options[:cols] && options[:rows]
+    # rows specified (already divided by 2), calculate cols for 16:9
+    # Multiply by 2 to get actual vertical dots before calculating horizontal
+    options[:cols] = (options[:rows] * 2.0 * 16.0 / 9.0).round
+  end
+
+  begin
+    converter = Rapicco::PDF::Converter.new(slide_file, output_pdf, options)
+    converter.convert
+  rescue => e
+    puts "Error: #{e.message}"
+    puts e.backtrace if ENV['DEBUG']
+    exit 1
+  end
+else
+  # Presentation mode
+  begin
+    presenter = Rapicco::Presenter.new(slide_file, options)
+    presenter.run
+  rescue => e
+    puts "Error: #{e.message}"
+    puts e.backtrace if ENV['DEBUG']
+    exit 1
+  end
+end

data/lib/rapicco/installer.rb

@@ -0,0 +1,144 @@
+require 'fileutils'
+require 'yaml'
+
+module Rapicco
+  class Installer
+    def initialize(dir_name, options = {})
+      @dir_name = dir_name
+      @options = options
+    end
+
+    def install
+      if @dir_name == '.'
+        # Install in current directory
+        target_dir = Dir.pwd
+        dir_display = 'current directory'
+      else
+        # Create new directory
+        if File.exist?(@dir_name)
+          raise "Directory '#{@dir_name}' already exists"
+        end
+        FileUtils.mkdir_p(@dir_name)
+        target_dir = @dir_name
+        dir_display = "'#{@dir_name}'"
+      end
+
+      FileUtils.mkdir_p(File.join(target_dir, 'pdf'))
+
+      create_gemfile(target_dir)
+      create_rakefile(target_dir)
+      create_slide(target_dir)
+      create_config(target_dir)
+      create_readme(target_dir)
+      create_gitignore(target_dir)
+
+      puts "Created slide template in #{dir_display}"
+      puts ""
+      puts "Next steps:"
+      unless @dir_name == '.'
+        puts "  cd #{@dir_name}"
+      end
+      puts "  bundle install"
+      puts "  bundle exec rake run    # Run presentation"
+      puts "  bundle exec rake pdf    # Generate PDF"
+      puts "  bundle exec rake gem    # Create gem package"
+    end
+
+    private
+
+    def create_gemfile(target_dir)
+      content = <<~GEMFILE
+        source 'https://rubygems.org'
+
+        gem 'rapicco'
+      GEMFILE
+
+      File.write(File.join(target_dir, 'Gemfile'), content)
+    end
+
+    def create_rakefile(target_dir)
+      content = <<~RAKEFILE
+        require 'rapicco/task/slide'
+      RAKEFILE
+
+      File.write(File.join(target_dir, 'Rakefile'), content)
+    end
+
+    def create_slide(target_dir)
+      content = <<~SLIDE
+        ---
+        duration: 300
+        sprite: hasumikin
+        title_font: terminus_8x16
+        font: terminus_6x12
+        bold_color: red
+        align: center
+        line_margin: 1
+        code_indent: 2
+        ---
+
+        # Title Slide
+        {align=center, scale=2}
+
+        Your presentation title
+
+        # Introduction
+
+        - Point 1
+        - Point 2
+        - Point 3
+
+        # Conclusion
+
+        Thank you!
+      SLIDE
+
+      File.write(File.join(target_dir, 'slide.md'), content)
+    end
+
+    def create_config(target_dir)
+      config = {
+        'id' => nil,
+        'base_name' => nil,
+        'tags' => [],
+        'version' => nil,
+        'licenses' => [],
+        'author' => {
+          'name' => nil,
+          'email' => nil,
+          'rubygems_user' => nil
+        }
+      }
+
+      File.write(File.join(target_dir, 'config.yml'), YAML.dump(config))
+    end
+
+    def create_readme(target_dir)
+      content = <<~README
+        # Slide Title
+
+        Your slide description here.
+
+        ## Author
+
+        Your Name
+
+        ## License
+
+        CC BY-SA 4.0
+      README
+
+      File.write(File.join(target_dir, 'README.md'), content)
+    end
+
+    def create_gitignore(target_dir)
+      content = <<~GITIGNORE
+        pdf/
+        pkg/
+        .DS_Store
+      GITIGNORE
+
+      File.write(File.join(target_dir, '.gitignore'), content)
+    end
+  end
+end

data/lib/rapicco/pdf/ansi_parser.rb

@@ -0,0 +1,245 @@
+module Rapicco
+  module PDF
+    class AnsiParser
+      ANSI_CSI_PATTERN = /\e\[([0-9;]*)([A-Za-z@])/
+      ANSI_RESET = /\e\[0m/
+
+      BLOCK_CHARS = {
+        "\u2588" => :full,
+        "\u2580" => :upper,
+        "\u2584" => :lower,
+        " " => :empty
+      }
+
+      COLOR_256_TO_RGB = {}
+
+      def initialize(cols: 80, rows: 24)
+        @cols = cols
+        @rows = rows
+        @screen = Array.new(rows) { Array.new(cols) { { char: ' ', fg: nil, bg: nil } } }
+        @cursor_x = 0
+        @cursor_y = 0
+        @current_fg = nil
+        @current_bg = nil
+        setup_color_palette
+      end
+
+      attr_reader :screen, :cols, :rows
+
+      def parse(text)
+        reset_screen
+        text = text.force_encoding('UTF-8') unless text.encoding == Encoding::UTF_8
+        chars = text.chars
+        i = 0
+        while i < chars.length
+          if chars[i] == "\e"
+            i = parse_escape_sequence_from_chars(chars, i)
+          else
+            write_char(chars[i])
+            i += 1
+          end
+        end
+        self
+      end
+
+      def reset_screen
+        @screen = Array.new(@rows) { Array.new(@cols) { { char: ' ', fg: nil, bg: nil } } }
+        @cursor_x = 0
+        @cursor_y = 0
+        @current_fg = nil
+        @current_bg = nil
+      end
+
+      private
+
+      def parse_escape_sequence_from_chars(chars, start)
+        if start + 1 < chars.length && chars[start + 1] == '['
+          # Build string from chars for regex matching
+          remaining = chars[start..-1].join
+          if match = remaining.match(ANSI_CSI_PATTERN)
+            params = match[1].split(';').map(&:to_i)
+            command = match[2]
+            handle_csi_command(command, params)
+            return start + match[0].length
+          end
+        end
+        start + 1
+      end
+
+      def handle_csi_command(command, params)
+        case command
+        when 'H', 'f'
+          row = params[0] || 1
+          col = params[1] || 1
+          @cursor_y = [row - 1, 0].max
+          @cursor_x = [col - 1, 0].max
+        when 'A'
+          @cursor_y = [@cursor_y - (params[0] || 1), 0].max
+        when 'B'
+          @cursor_y = [@cursor_y + (params[0] || 1), @rows - 1].min
+        when 'C'
+          @cursor_x = [@cursor_x + (params[0] || 1), @cols - 1].min
+        when 'D'
+          @cursor_x = [@cursor_x - (params[0] || 1), 0].max
+        when 'E'
+          @cursor_y = [@cursor_y + (params[0] || 1), @rows - 1].min
+          @cursor_x = 0
+        when 'F'
+          @cursor_y = [@cursor_y - (params[0] || 1), 0].max
+          @cursor_x = 0
+        when 'J'
+          clear_screen(params[0] || 0)
+        when 'K'
+          clear_line(params[0] || 0)
+        when '@'
+          # ICH - Insert Character: Insert blank characters at cursor position
+          # This shifts existing content to the right
+          count = params[0] || 1
+          return if @cursor_y >= @rows || @cursor_x >= @cols
+
+          # Shift existing characters to the right
+          count = [count, @cols - @cursor_x].min
+          if count > 0
+            # Move existing characters to the right
+            (@cols - 1).downto(@cursor_x + count) do |x|
+              if x >= @cursor_x + count && x - count >= @cursor_x
+                @screen[@cursor_y][x] = @screen[@cursor_y][x - count]
+              end
+            end
+            # Insert blank characters
+            (@cursor_x...[@cursor_x + count, @cols].min).each do |x|
+              @screen[@cursor_y][x] = { char: ' ', fg: @current_fg, bg: @current_bg }
+            end
+          end
+          # Cursor position does not change
+        when 'm'
+          handle_sgr(params.empty? ? [0] : params)
+        end
+      end
+
+      def handle_sgr(params)
+        i = 0
+        while i < params.length
+          case params[i]
+          when 0
+            @current_fg = nil
+            @current_bg = nil
+          when 31
+            @current_fg = [1.0, 0.0, 0.0]
+          when 32
+            @current_fg = [0.0, 1.0, 0.0]
+          when 33
+            @current_fg = [1.0, 1.0, 0.0]
+          when 34
+            @current_fg = [0.0, 0.0, 1.0]
+          when 35
+            @current_fg = [1.0, 0.0, 1.0]
+          when 36
+            @current_fg = [0.0, 1.0, 1.0]
+          when 37
+            @current_fg = [1.0, 1.0, 1.0]
+          when 38
+            if params[i + 1] == 5 && params[i + 2]
+              @current_fg = color_256_to_rgb(params[i + 2])
+              i += 2
+            end
+          when 48
+            if params[i + 1] == 5 && params[i + 2]
+              @current_bg = color_256_to_rgb(params[i + 2])
+              i += 2
+            end
+          end
+          i += 1
+        end
+      end
+
+      def clear_screen(mode)
+        case mode
+        when 0
+          (@cursor_y...@rows).each do |y|
+            start_x = y == @cursor_y ? @cursor_x : 0
+            (start_x...@cols).each do |x|
+              @screen[y][x] = { char: ' ', fg: nil, bg: nil }
+            end
+          end
+        when 1
+          (0..@cursor_y).each do |y|
+            end_x = y == @cursor_y ? @cursor_x : @cols - 1
+            (0..end_x).each do |x|
+              @screen[y][x] = { char: ' ', fg: nil, bg: nil }
+            end
+          end
+        when 2
+          @screen = Array.new(@rows) { Array.new(@cols) { { char: ' ', fg: nil, bg: nil } } }
+        end
+      end
+
+      def clear_line(mode)
+        case mode
+        when 0
+          (@cursor_x...@cols).each do |x|
+            @screen[@cursor_y][x] = { char: ' ', fg: nil, bg: nil }
+          end
+        when 1
+          (0..@cursor_x).each do |x|
+            @screen[@cursor_y][x] = { char: ' ', fg: nil, bg: nil }
+          end
+        when 2
+          (0...@cols).each do |x|
+            @screen[@cursor_y][x] = { char: ' ', fg: nil, bg: nil }
+          end
+        end
+      end
+
+      def write_char(char)
+        return if @cursor_y >= @rows
+        if char == "\n"
+          @cursor_y += 1
+          @cursor_x = 0
+        elsif char == "\r"
+          @cursor_x = 0
+        elsif char.ord >= 32
+          if @cursor_x < @cols
+            @screen[@cursor_y][@cursor_x] = {
+              char: char,
+              fg: @current_fg,
+              bg: @current_bg
+            }
+            @cursor_x += 1
+          end
+        end
+      end
+
+      def setup_color_palette
+        (0..255).each do |i|
+          COLOR_256_TO_RGB[i] = xterm_256_to_rgb(i)
+        end
+      end
+
+      def color_256_to_rgb(index)
+        COLOR_256_TO_RGB[index] || [1.0, 1.0, 1.0]
+      end
+
+      def xterm_256_to_rgb(index)
+        if index < 16
+          basic_colors = [
+            [0.0, 0.0, 0.0], [0.5, 0.0, 0.0], [0.0, 0.5, 0.0], [0.5, 0.5, 0.0],
+            [0.0, 0.0, 0.5], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5], [0.75, 0.75, 0.75],
+            [0.5, 0.5, 0.5], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 1.0, 0.0],
+            [0.0, 0.0, 1.0], [1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [1.0, 1.0, 1.0]
+          ]
+          basic_colors[index]
+        elsif index < 232
+          i = index - 16
+          r = (i / 36) * 51
+          g = ((i % 36) / 6) * 51
+          b = (i % 6) * 51
+          [r / 255.0, g / 255.0, b / 255.0]
+        else
+          gray = 8 + (index - 232) * 10
+          [gray / 255.0, gray / 255.0, gray / 255.0]
+        end
+      end
+    end
+  end
+end

data/lib/rapicco/pdf/page_capturer.rb

@@ -0,0 +1,99 @@
+require 'pty'
+require 'io/console'
+require 'timeout'
+
+module Rapicco
+  module PDF
+    class PageCapturer
+      def initialize(rapicco_command, slide_file, cols: 80, rows: 24)
+        @rapicco_command = rapicco_command
+        @slide_file = slide_file
+        @cols = cols
+        @rows = rows
+        @pages = []
+      end
+
+      attr_reader :pages
+
+      def capture_all_pages(max_pages: 100)
+        expected_pages = count_slides(@slide_file)
+        puts "Detected #{expected_pages} slides in presentation"
+
+        PTY.spawn("#{@rapicco_command} #{@slide_file}") do |stdout, stdin, pid|
+          stdin.winsize = [@rows, @cols]
+
+          puts "Waiting for Rapicco to start and render..."
+          sleep 3
+
+          current_page = capture_current_screen(stdout, timeout: 2.0)
+          if current_page
+            @pages << current_page
+            puts "Captured page 1/#{expected_pages} (#{current_page.length} bytes)"
+          end
+
+          (expected_pages - 1).times do |i|
+            puts "Sending 'l' for next page..."
+            stdin.write('l')
+            stdin.flush
+
+            sleep 1
+
+            page = capture_current_screen(stdout, timeout: 2.0)
+            unless page
+              puts "No output received, stopping"
+              break
+            end
+
+            @pages << page
+            puts "Captured page #{@pages.length}/#{expected_pages} (#{page.length} bytes)"
+          end
+
+          stdin.write("\x03")
+        rescue Errno::EIO => e
+          puts "PTY error: #{e.message}"
+        ensure
+          Process.kill('TERM', pid) rescue nil
+          Process.wait(pid) rescue nil
+        end
+
+        @pages
+      end
+
+      private
+
+      def count_slides(slide_file)
+        return 1 unless File.exist?(slide_file)
+
+        content = File.read(slide_file, encoding: 'UTF-8')
+        slide_count = content.lines.count { |line| line =~ /\A# / }
+
+        [slide_count, 1].max
+      end
+
+      def capture_current_screen(stdout, timeout: 2.0)
+        output = String.new(encoding: Encoding::BINARY)
+
+        begin
+          Timeout.timeout(timeout) do
+            loop do
+              output << stdout.read_nonblock(10000)
+            end
+          end
+        rescue Timeout::Error
+        rescue IO::WaitReadable
+        rescue EOFError, Errno::EIO
+          return nil
+        end
+
+        return nil if output.empty?
+        output.force_encoding(Encoding::UTF_8)
+
+        # Extract only the last frame to avoid animation artifacts
+        # Split by cursor home sequences which indicate a new frame
+        frames = output.split(/(?=\e\[H|\e\[1;1H)/)
+
+        frames.length > 1 ? frames.last : output
+      end
+    end
+  end
+end

data/lib/rapicco/pdf/renderer.rb

@@ -0,0 +1,74 @@
+require 'cairo'
+
+module Rapicco
+  module PDF
+    class Renderer
+      BLOCK_CHARS = {
+        "\u2588" => :full,
+        "\u2580" => :upper,
+        "\u2584" => :lower,
+        " " => :empty
+      }
+
+      def initialize(char_width: 10, char_height: 20)
+        @char_width = char_width
+        @char_height = char_height
+      end
+
+      def render(pages, output_path, parser_cols: 80, parser_rows: 24)
+        width = parser_cols * @char_width
+        height = parser_rows * @char_height
+
+        Cairo::PDFSurface.new(output_path, width, height) do |surface|
+          pages.each do |page_data|
+            context = Cairo::Context.new(surface)
+            render_page(page_data, context)
+            context.show_page
+          end
+        end
+      end
+
+      private
+
+      def render_page(screen, context)
+        context.set_source_rgb(0, 0, 0)
+        context.paint
+
+        screen.each_with_index do |line, y|
+          line.each_with_index do |cell, x|
+            render_cell(cell, x, y, context)
+          end
+        end
+      end
+
+      def render_cell(cell, x, y, context)
+        px = x * @char_width
+        py = y * @char_height
+
+        if cell[:bg]
+          context.set_source_rgb(*cell[:bg])
+          context.rectangle(px, py, @char_width, @char_height)
+          context.fill
+        end
+
+        char_type = BLOCK_CHARS[cell[:char]]
+        return unless char_type && cell[:fg]
+
+        context.set_source_rgb(*cell[:fg])
+
+        case char_type
+        when :full
+          context.rectangle(px, py, @char_width, @char_height)
+          context.fill
+        when :upper
+          context.rectangle(px, py, @char_width, @char_height / 2.0)
+          context.fill
+        when :lower
+          context.rectangle(px, py + @char_height / 2.0, @char_width, @char_height / 2.0)
+          context.fill
+        when :empty
+        end
+      end
+    end
+  end
+end

data/lib/rapicco/pdf.rb

@@ -0,0 +1,72 @@
+require_relative 'pdf/ansi_parser'
+require_relative 'pdf/page_capturer'
+require_relative 'pdf/renderer'
+
+module Rapicco
+  module PDF
+    class Converter
+      def initialize(slide_file, output_pdf, options = {})
+        @slide_file = slide_file
+        @output_pdf = output_pdf
+        @cols = options[:cols] || 500
+        @rows = options[:rows] || 140
+        @char_width = options[:char_width] || 5
+        @char_height = options[:char_height] || 10
+        @rapicco_command = options[:rapicco_command] || detect_picoruby_command
+      end
+
+      private
+
+      def detect_picoruby_command
+        unless ENV['PICORUBY_PATH']
+          raise <<~ERROR
+            PICORUBY_PATH environment variable is not set.
+
+            Please set it to the path of your picoruby executable:
+              export PICORUBY_PATH=/path/to/picoruby
+
+            Or use the --rapicco-command option:
+              rapicco --rapicco-command "/path/to/picoruby -e ..." <slide.md> <output.pdf>
+
+            To install PicoRuby, see: https://github.com/picoruby/picoruby
+          ERROR
+        end
+
+        unless File.executable?(ENV['PICORUBY_PATH'])
+          raise "PICORUBY_PATH is set to '#{ENV['PICORUBY_PATH']}' but it is not executable"
+        end
+
+        picoruby = ENV['PICORUBY_PATH']
+        "#{picoruby} -e \"require 'rapicco'; Rapicco.new(ARGV[0], cols: #{@cols}, rows: #{@rows}).run\""
+      end
+
+      public
+
+      def convert
+        puts "Capturing pages from Rapicco presentation via PTY..."
+        capturer = PageCapturer.new(@rapicco_command, @slide_file, cols: @cols, rows: @rows)
+        raw_pages = capturer.capture_all_pages
+
+        if raw_pages.empty?
+          raise "No pages captured. Check if Rapicco is working correctly."
+        end
+
+        puts "Captured #{raw_pages.length} raw pages"
+
+        puts "Parsing ANSI escape sequences..."
+        parsed_pages = raw_pages.map do |raw_page|
+          parser = AnsiParser.new(cols: @cols, rows: @rows)
+          parser.parse(raw_page)
+          parser.screen
+        end
+
+        puts "Rendering PDF..."
+        renderer = Renderer.new(char_width: @char_width, char_height: @char_height)
+        renderer.render(parsed_pages, @output_pdf, parser_cols: @cols, parser_rows: @rows)
+
+        puts "PDF created: #{@output_pdf}"
+      end
+    end
+  end
+end
+

data/lib/rapicco/presenter.rb

@@ -0,0 +1,52 @@
+require 'shellwords'
+
+module Rapicco
+  class Presenter
+    def initialize(slide_file, options = {})
+      @slide_file = slide_file
+      @rapicco_command = options[:rapicco_command] || detect_picoruby_command(options)
+    end
+
+    def run
+      # Disable terminal echo during presentation
+      system("stty -echo -icanon")
+
+      begin
+        system("#{@rapicco_command} #{Shellwords.shellescape(@slide_file)}")
+      ensure
+        # Restore terminal settings
+        system("stty echo icanon")
+        # Show cursor (CSI ? 25 h)
+        print "\e[?25h"
+        # Exit alternate screen buffer (CSI ? 1049 l)
+        print "\e[?1049l"
+        $stdout.flush
+      end
+    end
+
+    private
+
+    def detect_picoruby_command(options)
+      unless ENV['PICORUBY_PATH']
+        raise <<~ERROR
+          PICORUBY_PATH environment variable is not set.
+
+          Please set it to the path of your picoruby executable:
+            export PICORUBY_PATH=/path/to/picoruby
+
+          Or use the --rapicco-command option:
+            rapicco --rapicco-command "/path/to/picoruby -e ..." <slide.md>
+
+          To install PicoRuby, see: https://github.com/picoruby/picoruby
+        ERROR
+      end
+
+      unless File.executable?(ENV['PICORUBY_PATH'])
+        raise "PICORUBY_PATH is set to '#{ENV['PICORUBY_PATH']}' but it is not executable"
+      end
+
+      picoruby = ENV['PICORUBY_PATH']
+      "#{picoruby} -e \"require 'rapicco'; Rapicco.new(ARGV[0]).run\""
+    end
+  end
+end

data/lib/rapicco/slide_gem_builder.rb

@@ -0,0 +1,132 @@
+require 'fileutils'
+require 'rubygems/package'
+
+module Rapicco
+  class SlideGemBuilder
+    def initialize(config)
+      @config = config
+    end
+
+    def build
+      validate_config
+
+      FileUtils.mkdir_p('pkg')
+
+      spec = build_gemspec
+      gem_file = File.join('pkg', "#{spec.full_name}.gem")
+
+      if File.exist?(gem_file)
+        FileUtils.rm(gem_file)
+      end
+
+      Gem::Package.build(spec)
+      FileUtils.mv("#{spec.full_name}.gem", gem_file)
+
+      gem_file
+    end
+
+    private
+
+    def validate_config
+      errors = []
+
+      # Required fields
+      errors << "config.yml: 'id' is required" if @config['id'].nil? || @config['id'].empty?
+      errors << "config.yml: 'base_name' is required" if @config['base_name'].nil? || @config['base_name'].empty?
+      errors << "config.yml: 'version' is required" if @config['version'].nil? || @config['version'].empty?
+
+      # Licenses
+      if @config['licenses'].nil? || @config['licenses'].empty?
+        errors << "config.yml: 'licenses' must have at least one license"
+      end
+
+      # Author fields
+      if @config['author'].nil?
+        errors << "config.yml: 'author' section is required"
+      else
+        errors << "config.yml: 'author.name' is required" if @config['author']['name'].nil? || @config['author']['name'].empty?
+        errors << "config.yml: 'author.email' is required" if @config['author']['email'].nil? || @config['author']['email'].empty?
+        errors << "config.yml: 'author.rubygems_user' is required" if @config['author']['rubygems_user'].nil? || @config['author']['rubygems_user'].empty?
+      end
+
+      unless errors.empty?
+        raise <<~ERROR
+          Configuration validation failed:
+
+          #{errors.map { |e| "  - #{e}" }.join("\n")}
+
+          Please edit config.yml and fill in all required fields.
+        ERROR
+      end
+    end
+
+    def build_gemspec
+      config = @config
+      slide_file = find_slide_file
+      pdf_file = "pdf/#{config['id']}-#{config['base_name']}.pdf"
+
+      Gem::Specification.new do |spec|
+        spec.name = "rabbit-slide-#{config['author']['rubygems_user']}-#{config['id']}"
+        spec.version = config['version']
+        spec.authors = [config['author']['name']]
+        spec.email = [config['author']['email']]
+
+        spec.summary = "Rapicco slide: #{config['id']}"
+        spec.description = read_description
+        spec.homepage = "https://slide.rabbit-shocker.org/authors/#{config['author']['rubygems_user']}/#{config['id']}/"
+        spec.license = config['licenses'].first
+
+        spec.metadata = {
+          "rapicco.slide.id" => config['id'],
+          "rapicco.slide.base_name" => config['base_name'],
+          "rapicco.slide.tags" => config['tags'].join(',')
+        }
+
+        spec.files = [
+          slide_file,
+          pdf_file,
+          'config.yml',
+          'Rakefile',
+          'README.md'
+        ].select { |f| File.exist?(f) }
+
+        # Slide gems don't have Ruby code to require, but RubyGems requires at least one path
+        spec.require_paths = ["."]
+      end
+    end
+
+    def find_slide_file
+      if File.exist?('slide.md')
+        'slide.md'
+      else
+        Dir.glob('*.md').reject { |f| f == 'README.md' }.first
+      end
+    end
+
+    def read_description
+      return @config['id'] unless File.exist?('README.md')
+
+      readme = File.read('README.md')
+      # Extract first paragraph after title
+      lines = readme.lines
+      description_lines = []
+      found_title = false
+
+      lines.each do |line|
+        if line.start_with?('#')
+          found_title = true
+          next
+        end
+
+        next if line.strip.empty? && !found_title
+
+        if found_title
+          break if line.strip.empty? && !description_lines.empty?
+          description_lines << line.strip
+        end
+      end
+
+      description_lines.join(' ').strip[0..200]
+    end
+  end
+end

data/lib/rapicco/task/slide.rb

@@ -0,0 +1,80 @@
+require 'rake'
+require 'rake/tasklib'
+require 'yaml'
+require 'fileutils'
+require_relative '../slide_gem_builder'
+
+module Rapicco
+  module Task
+    class Slide < Rake::TaskLib
+      def initialize
+        @config = load_config
+        define_tasks
+      end
+
+      private
+
+      def load_config
+        unless File.exist?('config.yml')
+          raise "config.yml not found. Please create it first."
+        end
+        YAML.load_file('config.yml')
+      end
+
+      def define_tasks
+        desc "Run presentation"
+        task :run do
+          slide_file = find_slide_file
+          sh "rapicco #{slide_file}"
+        end
+
+        desc "Generate PDF"
+        task :pdf do
+          slide_file = find_slide_file
+          pdf_dir = 'pdf'
+          FileUtils.mkdir_p(pdf_dir)
+
+          pdf_name = "#{@config['id']}-#{@config['base_name']}.pdf"
+          pdf_path = File.join(pdf_dir, pdf_name)
+
+          sh "rapicco -p -o #{pdf_path} #{slide_file}"
+          puts "PDF created: #{pdf_path}"
+        end
+
+        desc "Create gem package"
+        task gem: :pdf do
+          builder = Rapicco::SlideGemBuilder.new(@config)
+          gem_file = builder.build
+          puts "Gem created: #{gem_file}"
+        end
+
+        desc "Publish gem to RubyGems.org"
+        task publish: :gem do
+          puts "Publishing gem is currently disabled."
+          #gem_file = gem_filename
+          #sh "gem push #{gem_file}"
+        end
+      end
+
+      def find_slide_file
+        # Look for .md files, prefer slide.md if it exists
+        if File.exist?('slide.md')
+          'slide.md'
+        else
+          md_files = Dir.glob('*.md').reject { |f| f == 'README.md' }
+          if md_files.empty?
+            raise "No slide file found. Please create a .md file."
+          end
+          md_files.first
+        end
+      end
+
+      def gem_filename
+        author_name = @config['author']['rubygems_user'].gsub(/[^a-z0-9\-_]/i, '-')
+        "pkg/rabbit-slide-#{author_name}-#{@config['id']}-#{@config['version']}.gem"
+      end
+    end
+  end
+end
+
+Rapicco::Task::Slide.new

data/lib/rapicco/version.rb

@@ -0,0 +1,3 @@
+module Rapicco
+  VERSION = "0.1.0"
+end

data/lib/rapicco.rb

@@ -0,0 +1,6 @@
+require_relative 'rapicco/version'
+require_relative 'rapicco/presenter'
+require_relative 'rapicco/pdf'
+require_relative 'rapicco/installer'
+require_relative 'rapicco/slide_gem_builder'
+

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: rapicco
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- HASUMI Hitoshi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cairo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A wrapper tool of PicoRuby Rapicco terminal-based presentation
+email: []
+executables:
+- rapicco
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/rapicco
+- lib/rapicco.rb
+- lib/rapicco/installer.rb
+- lib/rapicco/pdf.rb
+- lib/rapicco/pdf/ansi_parser.rb
+- lib/rapicco/pdf/page_capturer.rb
+- lib/rapicco/pdf/renderer.rb
+- lib/rapicco/presenter.rb
+- lib/rapicco/slide_gem_builder.rb
+- lib/rapicco/task/slide.rb
+- lib/rapicco/version.rb
+homepage: https://github.com/picoruby/rapicco
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.0.dev
+specification_version: 4
+summary: Rabbit-like presentation tool by PicoRuby
+test_files: []