demotape 0.0.0.pre.0

data/examples/tmux.tape

@@ -0,0 +1,28 @@
+Require "tmux"
+
+Pause
+  Send "tmux -f /dev/null -L test new-session -- bash"
+  Enter
+  Send "tmux split-window -d -h -- bash && \\"
+  Enter
+  Send "tmux set status && \\"
+  Enter
+  Send 'tmux setw pane-border-style "fg=0" && \\'
+  Enter
+  Send 'tmux setw pane-active-border-style "fg=0"'
+  Enter
+  Sleep 0.5
+  Ctrl+L
+  Sleep 1
+Resume
+
+Type "Window 1"
+Sleep 1
+
+# tmux bind to switch to next pane
+Ctrl+B
+Type "o"
+
+Sleep 1
+Type "Window 2"
+Sleep 1

data/examples/type.tape

@@ -0,0 +1,11 @@
+Sleep 1
+
+Type "Whatever you want"
+
+Sleep 1
+Ctrl+U
+Sleep 1
+
+Type@500ms "Slow down there, partner."
+
+Sleep 1

data/examples/type_file.tape

@@ -0,0 +1,23 @@
+Set variable_typing 0.3
+Require "vim"
+
+Sleep 1s
+Type "vim -u NONE -i NONE"
+Enter
+Sleep 1s
+
+# Enable syntax highlighting
+Shift+Colon
+Type "syntax on"
+Enter
+
+# Enable syntax highlighting
+Shift+Colon
+Type "source editors/vim/syntax/demotape.vim"
+Enter
+
+# Insert mode
+Type "i"
+
+TypeFile "examples/type_file.tape"
+Sleep 5s

data/examples/variable_typing.tape

@@ -0,0 +1,41 @@
+Set variable_typing 0.3
+Require "bat"
+Require "vim"
+
+Pause
+Send "rm -rf examples/script.rb && rm -rf \"examples/.script.rb*\"\n"
+WaitUntil /^$/
+Clear
+Resume
+
+Sleep 1s
+Type "vim -u NONE -i NONE examples/script.rb"
+Enter
+Sleep 1s
+
+# Enable syntax highlighting
+Shift+Colon
+Type "syntax on"
+Enter
+
+# Insert mode
+Type "i"
+
+Type """
+# This is a sample Ruby script
+puts "Hello, World!"
+
+"""
+
+Esc
+Sleep 3s
+Shift+Colon
+Type "x"
+Enter
+Sleep 1s
+Type "bat examples/script.rb"
+Enter
+Sleep 2s
+Type "ruby examples/script.rb"
+Enter
+Sleep 3s

data/examples/wait_until.tape

@@ -0,0 +1,8 @@
+Type "date"
+Enter
+Type "ruby -e '5.times { puts %[line #{_1 + 1} - #{Time.now}]; sleep 1 }'"
+Enter
+WaitUntil@11s /line 5/
+Type "date"
+Enter
+Wait 2s

data/examples/zsh.tape

@@ -0,0 +1,4 @@
+Set shell "zsh"
+Type@10ms "ps auxwww | grep $$ | grep -v grep"
+Enter
+Sleep 5s

data/exe/demotape

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/demo_tape"
+require_relative "../lib/demo_tape/cli"
+
+# `run` is reserved with thor 🫠🙄🤦‍♂️
+argv = ARGV.dup
+argv[0] = "_run" if argv[0] == "run"
+
+DemoTape::CLI.start(argv)

data/lib/demo_tape/bounds.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DemoTape
+  Bounds = Struct.new(
+    :padding_left,
+    :padding_top,
+    :with_padding_width,
+    :with_padding_height,
+    :margin_left,
+    :margin_top,
+    :with_margin_width,
+    :with_margin_height,
+    keyword_init: true
+  )
+end

data/lib/demo_tape/cli.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module DemoTape
+  class CLI < Thor
+    check_unknown_options!
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "run PATH", "Runs a demo tape"
+    option :typing_speed,
+           type: :string,
+           default: "50ms",
+           desc: "Global speed for typing"
+    option :variable_typing,
+           type: :numeric,
+           default: 0.25,
+           desc: "Whether to add variability to typing speed"
+    option :port,
+           type: :numeric,
+           default: 0,
+           desc: "Port for the ttyd server"
+    option :output_path,
+           type: :array,
+           default: [],
+           desc: "One or more paths to save the recorded terminal session"
+    option :shell,
+           type: :string,
+           enum: %w[zsh fish bash],
+           default: "zsh",
+           desc: "Shell to use for the terminal session"
+    option :rc_file,
+           type: :string,
+           desc: "Path to a shell rc file to source on startup"
+    option :no_rc,
+           type: :boolean,
+           default: false,
+           desc: "Do not load the default rc file"
+    option :theme,
+           type: :string,
+           default: "default_dark",
+           desc: "A built-in theme name or a path to a custom theme JSON file"
+    option :width,
+           type: :numeric,
+           default: 1920,
+           desc: "Output video width"
+    option :height,
+           type: :numeric,
+           default: 1080,
+           desc: "Output video height"
+    option :font_size,
+           type: :numeric,
+           default: 32,
+           desc: "Font size for the terminal session"
+    option :font_family,
+           type: :string,
+           default: %['JetBrainsMono Nerd Font Propo', monospace],
+           desc: "Font family for the terminal session"
+    option :line_height,
+           type: :numeric,
+           default: 1.2,
+           desc: "Line height for the terminal session"
+    option :cursor_blink,
+           type: :boolean,
+           default: true,
+           desc: "Whether the cursor blinks"
+    option :cursor_width,
+           type: :numeric,
+           default: 2,
+           desc: "The width of the cursor when in 'bar' style"
+    option :cursor_style,
+           type: :string,
+           enum: %w[block underline bar],
+           default: "block",
+           desc: "The style of the cursor when the terminal is focused."
+    option :letter_spacing,
+           type: :numeric,
+           default: 0,
+           desc: "Letter spacing for the terminal session"
+    option :padding,
+           type: :array,
+           default: [50],
+           desc: "Padding around the terminal content. " \
+                 "It can be 1, 2, or 4 numbers."
+    option :fps,
+           type: :numeric,
+           default: 24,
+           desc: "Frames per second for the output video"
+    option :overwrite,
+           type: :boolean,
+           default: false,
+           desc: "Whether to overwrite the output file if it exists"
+    option :debug,
+           type: :boolean,
+           default: false,
+           desc: "Show additional debug output"
+    option :loop,
+           type: :boolean,
+           default: true,
+           desc: "Loop the GIF infinitely"
+    option :loop_delay,
+           type: :numeric,
+           default: 0,
+           desc: "Delay time (in seconds) before restarting the GIF animation"
+    option :margin,
+           type: :array,
+           default: [0],
+           desc: "Margin around the terminal content. " \
+                 "It can be 1, 2, or 4 numbers."
+    option :margin_fill,
+           type: :string,
+           default: "#000000",
+           desc: "Color or image to use for the margin around the terminal " \
+                 "content"
+    option :border_radius,
+           type: :numeric,
+           default: 0,
+           desc: "Border radius for the terminal canvas"
+    option :screenshot_only,
+           type: :boolean,
+           desc: "Only take screenshots instead of recording a video"
+    option :screenshot,
+           type: :boolean,
+           default: false,
+           desc: "Take a single screenshot at the end of the session"
+    def _run(file_path = "")
+      options = self.options.dup
+      options[:padding] =
+        Spacing.new(*(options.padding * 4).take(4).map(&:to_i))
+      options[:margin] =
+        Spacing.new(*(options.margin * 4).take(4).map(&:to_i))
+
+      if file_path == ""
+        file_path = "<stdin>"
+        content = $stdin.read
+        options[:output_path] = "stdin.mp4" if options.output_path.empty?
+      else
+        content = File.read(file_path)
+      end
+
+      Runner.new(file_path:, content:, thor: shell, options:).run
+    end
+
+    desc "themes", "Lists available built-in themes"
+    def themes
+      Dir[File.join(__dir__, "themes", "*.json")].each do |path|
+        puts File.basename(path, ".json")
+      end
+    end
+
+    no_commands do
+      # Add helper methods here
+    end
+  end
+end

data/lib/demo_tape/command.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+module DemoTape
+  class Command
+    KEY_MAPPING = {
+      "Cancel" => :cancel,
+      "Help" => :help,
+      "Backspace" => :backspace,
+      "Tab" => :tab,
+      # "Clear" => :clear,
+      "Return" => :return,
+      "Enter" => :enter,
+      "Shift" => :shift,
+      "Control" => :control,
+      "Ctrl" => :control,
+      "Alt" => :alt,
+      "Option" => :alt,
+      "Pause" => :pause,
+      "Escape" => :escape,
+      "Esc" => :escape,
+      "Space" => :space,
+      "PageUp" => :page_up,
+      "PageDown" => :page_down,
+      "End" => :end,
+      "Home" => :home,
+      "Left" => :left,
+      "Up" => :up,
+      "Right" => :right,
+      "Down" => :down,
+      "Insert" => :insert,
+      "Delete" => :delete,
+      "Semicolon" => :semicolon,
+      "Colon" => ":",
+      "Equals" => :equals,
+      "Numpad0" => :numpad0,
+      "Numpad1" => :numpad1,
+      "Numpad2" => :numpad2,
+      "Numpad3" => :numpad3,
+      "Numpad4" => :numpad4,
+      "Numpad5" => :numpad5,
+      "Numpad6" => :numpad6,
+      "Numpad7" => :numpad7,
+      "Numpad8" => :numpad8,
+      "Numpad9" => :numpad9,
+      "Multiply" => :multiply,
+      "Add" => :add,
+      "Separator" => :separator,
+      "Subtract" => :subtract,
+      "Decimal" => :decimal,
+      "Divide" => :divide,
+      "F1" => :f1,
+      "F2" => :f2,
+      "F3" => :f3,
+      "F4" => :f4,
+      "F5" => :f5,
+      "F6" => :f6,
+      "F7" => :f7,
+      "F8" => :f8,
+      "F9" => :f9,
+      "F10" => :f10,
+      "F11" => :f11,
+      "F12" => :f12,
+      "Meta" => :meta,
+      "Command" => :command,
+      "Slash" => "/",
+      "BackSlash" => "\\"
+    }.freeze
+
+    VALID_COMMANDS = KEY_MAPPING.keys + %w[
+      Clear
+      Copy
+      Include
+      Output
+      Pause
+      Paste
+      Require
+      Resume
+      Screenshot
+      Send
+      Set
+      Sleep
+      Type
+      TypeFile
+      Wait
+      WaitUntil
+    ].freeze
+
+    META_COMMANDS = %w[Require Set Include Output].freeze
+    COMMANDS_WITH_SPEED = KEY_MAPPING.keys + %w[Type]
+    COMMANDS_WITH_TIMEOUT = %w[WaitUntil].freeze
+    VALID_TIME_UNITS = %w[ms s m h].freeze
+
+    # Valid keys that can be used in key combos
+    VALID_KEYS = KEY_MAPPING.keys + %w[
+      A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+      a b c d e f g h i j k l m n o p q r s t u v w x y z
+      0 1 2 3 4 5 6 7 8 9
+    ].freeze
+
+    SET_OPTIONS = %w[
+      border_radius cursor_blink cursor_style cursor_width font_family font_size
+      height line_height loop loop_delay margin margin_fill padding shell theme
+      typing_speed variable_typing width
+    ].freeze
+
+    attr_reader :type, :args, :options
+    attr_accessor :column, :duration_column, :file, :line, :line_content,
+                  :speed_column, :timeout_column, :tokens
+
+    def initialize(type, args = "", **options)
+      @type = type
+      @args = args
+      @options = options
+      @line = nil
+      @column = nil
+      @line_content = nil
+      @file = nil
+      @duration_column = nil
+      @speed_column = nil
+      @timeout_column = nil
+      @tokens = []
+    end
+
+    # Whether this command represents a key press
+    def key?
+      VALID_KEYS.include?(type)
+    end
+
+    def keys
+      return [] unless key?
+
+      keys = [to_key_value(type)]
+      keys += options.fetch(:keys, []).map { to_key_value(it) }
+
+      keys
+    end
+
+    def to_key_value(input)
+      KEY_MAPPING[input] || input.downcase
+    end
+
+    # Whether this command is a meta-command (i.e., not producing output)
+    # Meta commands are executed before regular commands.
+    def meta?
+      META_COMMANDS.include?(type)
+    end
+
+    def to_sym
+      @to_sym ||= type.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                      .tr("-", "_")
+                      .downcase
+                      .to_sym
+    end
+
+    def validate_command!
+      return if VALID_COMMANDS.include?(type)
+
+      raise_error "Unknown command: #{type.inspect}"
+    end
+
+    def validate_speed!
+      return unless options[:speed] && !COMMANDS_WITH_SPEED.include?(type)
+
+      raise_error "Command #{type.inspect} does not accept speed option"
+    end
+
+    def validate_timeout!
+      return unless options[:timeout] && !COMMANDS_WITH_TIMEOUT.include?(type)
+
+      raise_error "Command #{type.inspect} does not accept timeout option"
+    end
+
+    def validate_set_options!
+      return unless type == "Set"
+
+      # Handle nested options (e.g., theme.background)
+      base_option = options[:option].split(".").first
+
+      return if SET_OPTIONS.include?(base_option)
+
+      raise_error "Unknown option: #{options[:option].inspect} #{self}",
+                  column_override: tokens[1].column
+    end
+
+    def validate_keys!
+      return unless options[:keys]
+
+      all_keys = options[:keys] + [type]
+
+      all_keys.each do |key|
+        next if VALID_KEYS.include?(key)
+
+        unless VALID_COMMANDS.include?(key)
+          raise_error "Invalid key in combo: #{key.inspect}"
+        end
+
+        raise_error "Command #{key.inspect} doesn't support key combos"
+      end
+    end
+
+    def validate_regex!
+      return unless type == "WaitUntil"
+
+      raise_error "WaitUntil command requires a regex pattern" if args.empty?
+
+      begin
+        options[:pattern] = Regexp.new(args)
+      rescue RegexpError => error
+        raise_error "Invalid regex pattern: #{error.message}"
+      end
+    end
+
+    def prepare!
+      validate_command!
+      validate_speed!
+      validate_timeout!
+      normalize_theme_options!
+      validate_set_options!
+      validate_keys!
+      validate_regex!
+      validate_duration!
+      validate_type_file!
+
+      normalize_spacing_values!
+
+      self
+    end
+
+    private def validate_type_file!
+      return unless type == "TypeFile"
+
+      raise_error "TypeFile command requires a file path" if args.empty?
+    end
+
+    private def validate_duration!
+      [args, :duration] => [duration, source] if %w[Sleep Wait].include?(type)
+      [options[:speed], :speed] => [duration, source] if options[:speed]
+      [options[:timeout], :timeout] => [duration, source] if options[:timeout]
+
+      return unless duration
+
+      unit = duration[/[a-z]+$/i]
+      return if VALID_TIME_UNITS.include?(unit)
+
+      col = case source
+            when :speed then speed_column
+            when :timeout then timeout_column
+            else duration_column
+            end
+
+      raise_error "Invalid time unit: #{unit.inspect}", column_override: col
+    end
+
+    private def normalize_theme_options!
+      return unless type == "Set"
+      return unless options[:option]&.include?(".")
+
+      option, sub_option = *options[:option].split(".", 2)
+
+      unless option == "theme"
+        raise_error "Unexpected attribute #{options[:option].inspect}",
+                    column_override: tokens[1].column
+      end
+
+      unless Theme.valid_options.include?(sub_option.to_sym)
+        raise_error "Invalid theme property",
+                    column_override: tokens[1].column + 6 # ".theme".size
+      end
+
+      @options[:option] = option
+      @options[:sub_option] = sub_option
+    end
+
+    private def normalize_spacing_values!
+      return unless type == "Set"
+      return unless %w[padding margin].include?(options[:option])
+
+      @args = (Array(args).map(&:to_i) * 4).take(4)
+    end
+
+    def location(column_override: nil)
+      col = column_override || column
+      "#{file || '<unknown>'}:#{line}:#{col}"
+    end
+
+    def raise_error(message, column_override: nil)
+      col = column_override || column
+
+      raise DemoTape::ParseError, message unless line && col && line_content
+
+      error_msg = "#{message} at #{location(column_override:)}:\n"
+      error_msg += "  #{line_content}\n"
+      error_msg += "  #{' ' * (col - 1)}^"
+
+      raise DemoTape::ParseError, error_msg
+    end
+
+    def to_s
+      opts_str = options.empty? ? "" : " #{options.inspect}"
+      "#{type} #{args.inspect}#{opts_str}"
+    end
+
+    def to_formatted(thor)
+      return thor.set_color(type, :blue) unless tokens.any?
+
+      values = []
+
+      tokens.each_with_index do |token, index|
+        previous_token = tokens[index - 1]
+        preceded_by_comma = previous_token.is_a?(Token::Operator) &&
+                            previous_token.value == ","
+
+        case token
+        when Token::String
+          values << " "
+          values << thor.set_color(token.raw, :yellow)
+        when Token::Operator
+          values << thor.set_color(token.value, :white)
+        when Token::Number
+          values << " " unless previous_token.is_a?(Token::Operator)
+          values << " " if preceded_by_comma
+          values << thor.set_color(token.value, :magenta)
+        when Token::Duration
+          values << " " unless previous_token.is_a?(Token::Operator)
+          values << thor.set_color(token.value, :magenta)
+        when Token::Regex
+          values << " "
+          values << thor.set_color(token.raw, :green)
+        when Token::Identifier
+          values << " " if previous_token.is_a?(Token::Identifier)
+          values << thor.set_color(token.value, :blue)
+        else
+          raise "Unexpected token type: #{token.class.name}"
+        end
+      end
+
+      values.join.strip
+    end
+  end
+end