asciinema_win 0.1.0

data/lib/asciinema_win.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# AsciinemaWin - Native Windows Terminal Recorder in Pure Ruby
+#
+# A zero-dependency terminal recording and playback system for Windows.
+# Uses Ruby's built-in Fiddle for Win32 Console API access and integrates
+# Rich-Ruby for terminal rendering. Compatible with asciinema's asciicast v2 format.
+#
+# @example Record a terminal session
+#   AsciinemaWin.record("session.cast", title: "My Recording")
+#
+# @example Play back a recording
+#   AsciinemaWin.play("session.cast", speed: 1.5)
+#
+# @example Get recording info
+#   info = AsciinemaWin.info("session.cast")
+#   puts "Duration: #{info[:duration]}s"
+
+module AsciinemaWin
+  # Base error class for all AsciinemaWin errors
+  class Error < StandardError; end
+
+  # Raised when recording fails
+  class RecordingError < Error; end
+
+  # Raised when playback fails
+  class PlaybackError < Error; end
+
+  # Raised when file format is invalid
+  class FormatError < Error; end
+
+  # Raised when platform is not supported
+  class PlatformError < Error; end
+
+  # Raised when export fails
+  class ExportError < Error; end
+end
+
+require_relative "rich"
+require_relative "asciinema_win/version"
+require_relative "asciinema_win/screen_buffer"
+require_relative "asciinema_win/asciicast"
+require_relative "asciinema_win/recorder"
+require_relative "asciinema_win/player"
+require_relative "asciinema_win/themes"
+require_relative "asciinema_win/ansi_parser"
+require_relative "asciinema_win/output_organizer"
+require_relative "asciinema_win/export"
+require_relative "asciinema_win/cli"
+
+module AsciinemaWin
+
+  class << self
+    # Record a terminal session to a file
+    #
+    # @param output_path [String] Path to save the recording
+    # @param title [String, nil] Recording title
+    # @param command [String, nil] Command to record (runs in subprocess)
+    # @param idle_time_limit [Float] Maximum idle time between events
+    # @param env_vars [Array<String>] Environment variables to capture
+    # @yield [Recorder] Optional block for manual recording control
+    # @return [void]
+    # @raise [RecordingError] If recording fails
+    # @raise [PlatformError] If not running on Windows
+    #
+    # @example Record interactively
+    #   AsciinemaWin.record("session.cast", title: "Demo") do |rec|
+    #     # Recording happens until block exits or user presses Ctrl+D
+    #   end
+    #
+    # @example Record a command
+    #   AsciinemaWin.record("session.cast", command: "dir /s")
+    def record(output_path, title: nil, command: nil, idle_time_limit: 2.0, env_vars: %w[SHELL TERM], &block)
+      ensure_windows!
+
+      recorder = Recorder.new(
+        title: title,
+        command: command,
+        idle_time_limit: idle_time_limit,
+        env_vars: env_vars
+      )
+
+      recorder.record(output_path, &block)
+    end
+
+    # Play back a recording from a file
+    #
+    # @param input_path [String] Path to the recording file
+    # @param speed [Float] Playback speed multiplier (1.0 = normal)
+    # @param idle_time_limit [Float, nil] Cap idle time between frames
+    # @param pause_on_markers [Boolean] Pause playback at markers
+    # @return [void]
+    # @raise [PlaybackError] If playback fails
+    # @raise [FormatError] If file format is invalid
+    #
+    # @example Normal playback
+    #   AsciinemaWin.play("session.cast")
+    #
+    # @example Fast playback
+    #   AsciinemaWin.play("session.cast", speed: 2.0)
+    def play(input_path, speed: 1.0, idle_time_limit: nil, pause_on_markers: false)
+      player = Player.new(
+        speed: speed,
+        idle_time_limit: idle_time_limit,
+        pause_on_markers: pause_on_markers
+      )
+
+      player.play(input_path)
+    end
+
+    # Output recording to stdout without timing (for piping)
+    #
+    # @param input_path [String] Path to the recording file
+    # @return [void]
+    # @raise [FormatError] If file format is invalid
+    def cat(input_path)
+      player = Player.new(speed: Float::INFINITY)
+      player.play(input_path)
+    end
+
+    # Get metadata about a recording
+    #
+    # @param input_path [String] Path to the recording file
+    # @return [Hash] Recording metadata including width, height, duration, title
+    # @raise [FormatError] If file format is invalid
+    #
+    # @example
+    #   info = AsciinemaWin.info("session.cast")
+    #   puts "Size: #{info[:width]}x#{info[:height]}"
+    #   puts "Duration: #{info[:duration]}s"
+    def info(input_path)
+      Asciicast::Reader.info(input_path)
+    end
+
+    # Run the CLI with the given arguments
+    #
+    # @param args [Array<String>] Command-line arguments
+    # @return [Integer] Exit code
+    def run(args = ARGV)
+      CLI.run(args)
+    end
+
+    private
+
+    # @raise [PlatformError] If not running on Windows
+    # @return [void]
+    def ensure_windows!
+      return if Gem.win_platform?
+
+      raise PlatformError, "AsciinemaWin requires Windows. Use the standard asciinema on other platforms."
+    end
+  end
+end

data/lib/rich/_palettes.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "color_triplet"
+
+module Rich
+  # Color palette definitions for terminal color systems.
+  # Provides lookup tables for standard 16-color, 256-color (8-bit),
+  # and Windows console color palettes.
+  module Palettes
+    # Standard 16-color ANSI palette (colors 0-15)
+    # These are the typical default colors, but terminals may customize them
+    STANDARD_PALETTE = [
+      ColorTriplet.new(0, 0, 0),        # 0: Black
+      ColorTriplet.new(128, 0, 0),      # 1: Red
+      ColorTriplet.new(0, 128, 0),      # 2: Green
+      ColorTriplet.new(128, 128, 0),    # 3: Yellow
+      ColorTriplet.new(0, 0, 128),      # 4: Blue
+      ColorTriplet.new(128, 0, 128),    # 5: Magenta
+      ColorTriplet.new(0, 128, 128),    # 6: Cyan
+      ColorTriplet.new(192, 192, 192),  # 7: White
+      ColorTriplet.new(128, 128, 128),  # 8: Bright Black (Gray)
+      ColorTriplet.new(255, 0, 0),      # 9: Bright Red
+      ColorTriplet.new(0, 255, 0),      # 10: Bright Green
+      ColorTriplet.new(255, 255, 0),    # 11: Bright Yellow
+      ColorTriplet.new(0, 0, 255),      # 12: Bright Blue
+      ColorTriplet.new(255, 0, 255),    # 13: Bright Magenta
+      ColorTriplet.new(0, 255, 255),    # 14: Bright Cyan
+      ColorTriplet.new(255, 255, 255)   # 15: Bright White
+    ].freeze
+
+    # Windows Console palette (slightly different from ANSI standard)
+    WINDOWS_PALETTE = [
+      ColorTriplet.new(12, 12, 12),     # 0: Black
+      ColorTriplet.new(197, 15, 31),    # 1: Red
+      ColorTriplet.new(19, 161, 14),    # 2: Green
+      ColorTriplet.new(193, 156, 0),    # 3: Yellow
+      ColorTriplet.new(0, 55, 218),     # 4: Blue
+      ColorTriplet.new(136, 23, 152),   # 5: Magenta
+      ColorTriplet.new(58, 150, 221),   # 6: Cyan
+      ColorTriplet.new(204, 204, 204),  # 7: White
+      ColorTriplet.new(118, 118, 118),  # 8: Bright Black (Gray)
+      ColorTriplet.new(231, 72, 86),    # 9: Bright Red
+      ColorTriplet.new(22, 198, 12),    # 10: Bright Green
+      ColorTriplet.new(249, 241, 165),  # 11: Bright Yellow
+      ColorTriplet.new(59, 120, 255),   # 12: Bright Blue
+      ColorTriplet.new(180, 0, 158),    # 13: Bright Magenta
+      ColorTriplet.new(97, 214, 214),   # 14: Bright Cyan
+      ColorTriplet.new(242, 242, 242)   # 15: Bright White
+    ].freeze
+
+    # Generate the 256-color (8-bit) palette
+    # Colors 0-15: Standard colors
+    # Colors 16-231: 6x6x6 color cube
+    # Colors 232-255: Grayscale ramp
+    EIGHT_BIT_PALETTE = begin
+      palette = []
+
+      # Colors 0-15: Standard palette
+      STANDARD_PALETTE.each { |color| palette << color }
+
+      # Colors 16-231: 6x6x6 color cube
+      # Each component can be 0, 95, 135, 175, 215, or 255
+      cube_values = [0, 95, 135, 175, 215, 255]
+      (0...6).each do |r|
+        (0...6).each do |g|
+          (0...6).each do |b|
+            palette << ColorTriplet.new(cube_values[r], cube_values[g], cube_values[b])
+          end
+        end
+      end
+
+      # Colors 232-255: Grayscale ramp (24 shades, excluding black and white)
+      (0...24).each do |i|
+        gray = 8 + i * 10
+        palette << ColorTriplet.new(gray, gray, gray)
+      end
+
+      palette.freeze
+    end
+
+    class << self
+      # Find the closest color in a palette
+      # @param triplet [ColorTriplet] Color to match
+      # @param palette [Array<ColorTriplet>] Palette to search
+      # @param start_index [Integer] Starting index in palette
+      # @param end_index [Integer] Ending index in palette (exclusive)
+      # @return [Integer] Index of closest matching color
+      def match_color(triplet, palette: EIGHT_BIT_PALETTE, start_index: 0, end_index: nil)
+        end_index ||= palette.length
+
+        best_index = start_index
+        best_distance = Float::INFINITY
+
+        (start_index...end_index).each do |i|
+          distance = triplet.weighted_distance(palette[i])
+          if distance < best_distance
+            best_distance = distance
+            best_index = i
+          end
+        end
+
+        best_index
+      end
+
+      # Match to standard 16-color palette
+      # @param triplet [ColorTriplet] Color to match
+      # @return [Integer] Standard color index (0-15)
+      def match_standard(triplet)
+        match_color(triplet, palette: STANDARD_PALETTE, start_index: 0, end_index: 16)
+      end
+
+      # Match to 8-bit palette (256 colors)
+      # @param triplet [ColorTriplet] Color to match
+      # @return [Integer] 8-bit color index (0-255)
+      def match_eight_bit(triplet)
+        match_color(triplet, palette: EIGHT_BIT_PALETTE, start_index: 0, end_index: 256)
+      end
+
+      # Match to Windows console palette
+      # @param triplet [ColorTriplet] Color to match
+      # @return [Integer] Windows color index (0-15)
+      def match_windows(triplet)
+        match_color(triplet, palette: WINDOWS_PALETTE, start_index: 0, end_index: 16)
+      end
+
+      # Get a color from the 8-bit palette
+      # @param index [Integer] Color index (0-255)
+      # @return [ColorTriplet]
+      def get_eight_bit(index)
+        EIGHT_BIT_PALETTE[index.clamp(0, 255)]
+      end
+
+      # Get a color from the standard palette
+      # @param index [Integer] Color index (0-15)
+      # @return [ColorTriplet]
+      def get_standard(index)
+        STANDARD_PALETTE[index.clamp(0, 15)]
+      end
+
+      # Get a color from the Windows palette
+      # @param index [Integer] Color index (0-15)
+      # @return [ColorTriplet]
+      def get_windows(index)
+        WINDOWS_PALETTE[index.clamp(0, 15)]
+      end
+    end
+  end
+end

data/lib/rich/box.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module Rich
+  # Box drawing character sets for borders and tables
+  class Box
+    # @return [String] Top-left corner
+    attr_reader :top_left
+
+    # @return [String] Top-right corner
+    attr_reader :top_right
+
+    # @return [String] Bottom-left corner
+    attr_reader :bottom_left
+
+    # @return [String] Bottom-right corner
+    attr_reader :bottom_right
+
+    # @return [String] Horizontal line
+    attr_reader :horizontal
+
+    # @return [String] Vertical line
+    attr_reader :vertical
+
+    # @return [String] Left T-junction
+    attr_reader :left_t
+
+    # @return [String] Right T-junction
+    attr_reader :right_t
+
+    # @return [String] Top T-junction
+    attr_reader :top_t
+
+    # @return [String] Bottom T-junction
+    attr_reader :bottom_t
+
+    # @return [String] Cross/plus junction
+    attr_reader :cross
+
+    # @return [String] Thick horizontal (for headers)
+    attr_reader :thick_horizontal
+
+    # @return [String] Thick left T-junction
+    attr_reader :thick_left_t
+
+    # @return [String] Thick right T-junction
+    attr_reader :thick_right_t
+
+    # @return [String] Thick cross
+    attr_reader :thick_cross
+
+    def initialize(
+      top_left:,
+      top_right:,
+      bottom_left:,
+      bottom_right:,
+      horizontal:,
+      vertical:,
+      left_t: nil,
+      right_t: nil,
+      top_t: nil,
+      bottom_t: nil,
+      cross: nil,
+      thick_horizontal: nil,
+      thick_left_t: nil,
+      thick_right_t: nil,
+      thick_cross: nil
+    )
+      @top_left = top_left
+      @top_right = top_right
+      @bottom_left = bottom_left
+      @bottom_right = bottom_right
+      @horizontal = horizontal
+      @vertical = vertical
+      @left_t = left_t || vertical
+      @right_t = right_t || vertical
+      @top_t = top_t || horizontal
+      @bottom_t = bottom_t || horizontal
+      @cross = cross || "+"
+      @thick_horizontal = thick_horizontal || horizontal
+      @thick_left_t = thick_left_t || @left_t
+      @thick_right_t = thick_right_t || @right_t
+      @thick_cross = thick_cross || @cross
+      freeze
+    end
+
+    # Get the top edge
+    # @param width [Integer] Width of content
+    # @return [String]
+    def top_edge(width)
+      "#{@top_left}#{@horizontal * [0, width - 2].max}#{@top_right}"
+    end
+
+    # Get the bottom edge
+    # @param width [Integer] Width of content
+    # @return [String]
+    def bottom_edge(width)
+      "#{@bottom_left}#{@horizontal * [0, width - 2].max}#{@bottom_right}"
+    end
+
+    # Get the row separator
+    # @param width_or_cells [Integer, Array] Total width or array of cell contents
+    # @param widths [Array<Integer>, nil] Array of column widths
+    # @return [String]
+    def row(width_or_cells, widths = nil)
+      if widths
+        # Table row separator with multiple columns
+        parts = widths.map { |w| @horizontal * w }
+        "#{@left_t}#{parts.join(@cross)}#{@right_t}"
+      else
+        # Single column separator
+        width = width_or_cells.is_a?(Integer) ? width_or_cells : Cells.cell_len(width_or_cells.to_s)
+        "#{@left_t}#{@horizontal * [0, width - 2].max}#{@right_t}"
+      end
+    end
+
+    alias top top_edge
+    alias bottom bottom_edge
+
+    # Get a content row
+    # @param content [String] Content
+    # @param width [Integer] Width to pad to
+    # @param align [Symbol] Alignment (:left, :center, :right)
+    # @return [String]
+    def content_row(content, width, align: :left)
+      content_len = Cells.cell_len(content)
+      padding = width - content_len
+
+      case align
+      when :center
+        left_pad = padding / 2
+        right_pad = padding - left_pad
+        "#{@vertical}#{' ' * left_pad}#{content}#{' ' * right_pad}#{@vertical}"
+      when :right
+        "#{@vertical}#{' ' * padding}#{content}#{@vertical}"
+      else # :left
+        "#{@vertical}#{content}#{' ' * padding}#{@vertical}"
+      end
+    end
+
+    # Get header separator (thicker line)
+    # @param width [Integer] Width
+    # @return [String]
+    def header_separator(width)
+      "#{@thick_left_t}#{@thick_horizontal * width}#{@thick_right_t}"
+    end
+
+    # Substitute ASCII characters for box characters
+    # @return [Box]
+    def to_ascii
+      ASCII
+    end
+
+    # Check if this is the ASCII box
+    # @return [Boolean]
+    def ascii?
+      self == ASCII
+    end
+
+    # Predefined box styles
+    class << self
+      # ASCII characters only
+      def ascii
+        ASCII
+      end
+
+      # Standard Unicode box drawing
+      def square
+        SQUARE
+      end
+
+      # Rounded corners
+      def rounded
+        ROUNDED
+      end
+
+      # Heavy/thick lines
+      def heavy
+        HEAVY
+      end
+
+      # Double lines
+      def double
+        DOUBLE
+      end
+
+      # Minimal (no corners)
+      def minimal
+        MINIMAL
+      end
+
+      # Simple horizontal lines only
+      def simple
+        SIMPLE
+      end
+
+      # No border
+      def none
+        NONE
+      end
+    end
+
+    # ASCII box (works everywhere)
+    ASCII = new(
+      top_left: "+",
+      top_right: "+",
+      bottom_left: "+",
+      bottom_right: "+",
+      horizontal: "-",
+      vertical: "|",
+      left_t: "+",
+      right_t: "+",
+      top_t: "+",
+      bottom_t: "+",
+      cross: "+",
+      thick_horizontal: "=",
+      thick_left_t: "+",
+      thick_right_t: "+",
+      thick_cross: "+"
+    )
+
+    # Standard Unicode box
+    SQUARE = new(
+      top_left: "┌",
+      top_right: "┐",
+      bottom_left: "└",
+      bottom_right: "┘",
+      horizontal: "─",
+      vertical: "│",
+      left_t: "├",
+      right_t: "┤",
+      top_t: "┬",
+      bottom_t: "┴",
+      cross: "┼",
+      thick_horizontal: "━",
+      thick_left_t: "┝",
+      thick_right_t: "┥",
+      thick_cross: "┿"
+    )
+
+    # Rounded corners
+    ROUNDED = new(
+      top_left: "╭",
+      top_right: "╮",
+      bottom_left: "╰",
+      bottom_right: "╯",
+      horizontal: "─",
+      vertical: "│",
+      left_t: "├",
+      right_t: "┤",
+      top_t: "┬",
+      bottom_t: "┴",
+      cross: "┼",
+      thick_horizontal: "━",
+      thick_left_t: "┝",
+      thick_right_t: "┥",
+      thick_cross: "┿"
+    )
+
+    # Heavy/thick box
+    HEAVY = new(
+      top_left: "┏",
+      top_right: "┓",
+      bottom_left: "┗",
+      bottom_right: "┛",
+      horizontal: "━",
+      vertical: "┃",
+      left_t: "┣",
+      right_t: "┫",
+      top_t: "┳",
+      bottom_t: "┻",
+      cross: "╋",
+      thick_horizontal: "━",
+      thick_left_t: "┣",
+      thick_right_t: "┫",
+      thick_cross: "╋"
+    )
+
+    # Double line box
+    DOUBLE = new(
+      top_left: "╔",
+      top_right: "╗",
+      bottom_left: "╚",
+      bottom_right: "╝",
+      horizontal: "═",
+      vertical: "║",
+      left_t: "╠",
+      right_t: "╣",
+      top_t: "╦",
+      bottom_t: "╩",
+      cross: "╬",
+      thick_horizontal: "═",
+      thick_left_t: "╠",
+      thick_right_t: "╣",
+      thick_cross: "╬"
+    )
+
+    # Minimal (dashes, no corners)
+    MINIMAL = new(
+      top_left: " ",
+      top_right: " ",
+      bottom_left: " ",
+      bottom_right: " ",
+      horizontal: "─",
+      vertical: " ",
+      left_t: " ",
+      right_t: " ",
+      top_t: "─",
+      bottom_t: "─",
+      cross: "─"
+    )
+
+    # Simple (just horizontal lines)
+    SIMPLE = new(
+      top_left: "",
+      top_right: "",
+      bottom_left: "",
+      bottom_right: "",
+      horizontal: "─",
+      vertical: "",
+      left_t: "",
+      right_t: "",
+      top_t: "",
+      bottom_t: "",
+      cross: ""
+    )
+
+    # No border at all
+    NONE = new(
+      top_left: "",
+      top_right: "",
+      bottom_left: "",
+      bottom_right: "",
+      horizontal: "",
+      vertical: "",
+      left_t: "",
+      right_t: "",
+      top_t: "",
+      bottom_t: "",
+      cross: ""
+    )
+  end
+end