tmux-fingers/spec/tmuxomatic_setup.rb

require "rspec/expectations"
require "byebug"
require "timeout"

shared_context "tmuxomatic setup", a: :b do
  let(:tmuxomatic) do
    Tmux.instance.socket = "tmuxomatic"
    Tmux.instance.config_file = "/dev/null"

    # TODO: resize window to 80x24?

    Tmux.instance
  end

  let(:config_name) { "basic" }
  let(:prefix) { "C-a" }
  let(:fingers_key) { "F" }
  let(:tmuxomatic_window_width) { 80 }
  let(:tmuxomatic_window_height) { 24 }

  let(:tmuxomatic_pane_id) { tmuxomatic.panes.first["pane_id"] }
  let(:tmuxomatic_window_id) { tmuxomatic.panes.first["window_id"] }
  let(:wait_for_initial_clear) { true }

  # Like sleep, but slower on CI lol
  def zzz(amount)
    sleep ENV["CI"] ? amount * 2 : amount
  end

  def send_keys(keys, trace_benchmark: false)
    fork do
      tmuxomatic.send_keys(tmuxomatic_pane_id, keys)
    end
    # TODO: detect when key is received, is it even possible?
    zzz 1.0
  end

  def exec(cmd, wait: true)
    wait_for_trace(trace: "command-completed", wait: wait) do
      tmuxomatic.pane_exec(tmuxomatic_pane_id, cmd)
    end
  end

  def wait_for_trace(trace:, wait: true)
    trace_count_before = count_in_log_file(trace)

    yield

    return unless wait

    Timeout.timeout(10) do
      noop while count_in_log_file(trace) <= trace_count_before
    end
  end

  def noop
  end

  def wait_for_fingers_teardown
    Timeout.timeout(10) do
      sleep 0.2 while tmuxomatic.capture_pane(tmuxomatic_pane_id).include?("[fingers]")
    end
  end

  def capture_pane
    tmuxomatic.capture_pane(tmuxomatic_pane_id)
  end

  def count_in_log_file(str)
    File.read(Fingers::Dirs::LOG_PATH).scan(str).length
  end

  def invoke_fingers(trace_benchmark: false)
    wait_for_trace(trace: "fingers-ready", wait: true) do
      send_keys(prefix)
      send_keys(fingers_key, trace_benchmark: trace_benchmark)
    end
    zzz 1.0
  end

  def echo_yanked
    wait_for_fingers_teardown
    exec("clear")
    send_keys("echo yanked text is ")
    paste
  end

  def paste
    send_keys(prefix)
    send_keys("]")
    zzz 0.5
  end

  def send_prefix_and(keys)
    send_keys(prefix)
    send_keys(keys)
  end

  def tmuxomatic_unlock_path
    File.expand_path(File.join(File.dirname(__FILE__), ".tmuxomatic_unlock_command_prompt"))
  end

  def fingers_root
    File.expand_path(File.join(File.dirname(__FILE__), "../"))
  end

  def fingers_stubs_path
    File.expand_path(File.join(
      fingers_root,
      "./spec/stubs"
    ))
  end

  before do
    conf_path = File.expand_path(
      File.join(
        File.dirname(__FILE__),
        "../spec/conf/",
        "#{config_name}.conf"
      )
    )

    tmuxomatic
    tmuxomatic.new_session("tmuxomatic", "PATH=\"#{fingers_root}:#{fingers_stubs_path}:$PATH\" TMUX='' tmux -L tmuxomatic_inner -f #{conf_path}", tmuxomatic_window_width, tmuxomatic_window_height)
    tmuxomatic.set_global_option("prefix", "None")
    tmuxomatic.set_global_option("status", "off")
    tmuxomatic.resize_window(tmuxomatic_window_id, tmuxomatic_window_width, tmuxomatic_window_height)

    `touch #{Fingers::Dirs::LOG_PATH}`

    # TODO: find out how to wait until tmux is ready
    zzz 1.0

    exec("export PS1='# '", wait: false)
    zzz 1.0
    exec("export PROMPT_COMMAND='#{tmuxomatic_unlock_path}'", wait: false)
    zzz 1.0

    exec("clear", wait: wait_for_initial_clear)
  end

  after do
    `pgrep -f tmuxomatic | xargs kill -9 &> /dev/null`
  end
end

def wrap_in_box(output, width)
  "┌" + "─" * width + "┐\n" +
    output.split("\n").map do |line|
      "│" + line.ljust(width, " ") + "│"
    end.join("\n") + "\n" +
    "└" + "─" * width + "┘"
end

RSpec::Matchers.define :contain_content do |expected|
  pane_output = nil
  pane = nil

  match do
    pane = tmuxomatic.pane_by_id(tmuxomatic_pane_id)
    pane_output = tmuxomatic.capture_pane(tmuxomatic_pane_id)
    pane_output.include?(expected)
  end

  failure_message do |_actual|
    "Could not find '#{expected}' in:\n" +
      wrap_in_box(pane_output, pane.pane_width.to_i)
  end
end