mirror of
https://github.com/TECHNOFAB11/tmux-copyrat.git
synced 2025-12-12 16:10:07 +01:00
493 lines
15 KiB
Rust
493 lines
15 KiB
Rust
use clap::Clap;
|
|
use regex::Regex;
|
|
use std::collections::HashMap;
|
|
use std::process::Command;
|
|
use std::str::FromStr;
|
|
use std::time::{SystemTime, UNIX_EPOCH};
|
|
|
|
use copyrat::{error, process, CliOpt};
|
|
|
|
mod tmux;
|
|
|
|
trait Executor {
|
|
fn execute(&mut self, args: Vec<String>) -> String;
|
|
fn last_executed(&self) -> Option<Vec<String>>;
|
|
}
|
|
|
|
struct RealShell {
|
|
executed: Option<Vec<String>>,
|
|
}
|
|
|
|
impl RealShell {
|
|
fn new() -> RealShell {
|
|
RealShell { executed: None }
|
|
}
|
|
}
|
|
|
|
impl Executor for RealShell {
|
|
fn execute(&mut self, args: Vec<String>) -> String {
|
|
let execution = Command::new(args[0].as_str())
|
|
.args(&args[1..])
|
|
.output()
|
|
.expect("Execution failed");
|
|
|
|
self.executed = Some(args);
|
|
|
|
let output: String = String::from_utf8_lossy(&execution.stdout).into();
|
|
|
|
output.trim_end().to_string()
|
|
}
|
|
|
|
fn last_executed(&self) -> Option<Vec<String>> {
|
|
self.executed.clone()
|
|
}
|
|
}
|
|
|
|
const TMP_FILE: &str = "/tmp/copyrat-last";
|
|
|
|
pub struct Swapper<'a> {
|
|
executor: Box<&'a mut dyn Executor>,
|
|
// directory: &'a path::Path,
|
|
command: &'a str,
|
|
alt_command: &'a str,
|
|
active_pane_id: Option<String>,
|
|
active_pane_height: Option<i32>,
|
|
active_pane_scroll_position: Option<i32>,
|
|
active_pane_in_copy_mode: Option<String>,
|
|
thumbs_pane_id: Option<String>,
|
|
content: Option<String>,
|
|
signal: String,
|
|
}
|
|
|
|
impl<'a> Swapper<'a> {
|
|
fn new(
|
|
executor: Box<&'a mut dyn Executor>,
|
|
// directory: &'a path::Path,
|
|
command: &'a str,
|
|
alt_command: &'a str,
|
|
) -> Swapper<'a> {
|
|
let since_the_epoch = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.expect("Time went backwards");
|
|
let signal = format!("thumbs-finished-{}", since_the_epoch.as_secs());
|
|
|
|
Swapper {
|
|
executor,
|
|
// directory,
|
|
command,
|
|
alt_command,
|
|
active_pane_id: None,
|
|
active_pane_height: None,
|
|
active_pane_scroll_position: None,
|
|
active_pane_in_copy_mode: None,
|
|
thumbs_pane_id: None,
|
|
content: None,
|
|
signal,
|
|
}
|
|
}
|
|
|
|
pub fn capture_active_pane(&mut self) {
|
|
let active_command = vec![
|
|
"tmux",
|
|
"list-panes",
|
|
"-F",
|
|
"#{pane_id}:#{?pane_in_mode,1,0}:#{pane_height}:#{scroll_position}:#{?pane_active,active,nope}",
|
|
];
|
|
|
|
let output = self
|
|
.executor
|
|
.execute(active_command.iter().map(|arg| arg.to_string()).collect());
|
|
|
|
let lines: Vec<&str> = output.split('\n').collect();
|
|
let chunks: Vec<Vec<&str>> = lines
|
|
.into_iter()
|
|
.map(|line| line.split(':').collect())
|
|
.collect();
|
|
|
|
let active_pane = chunks
|
|
.iter()
|
|
.find(|&chunks| *chunks.get(4).unwrap() == "active")
|
|
.expect("Unable to find active pane");
|
|
|
|
let pane_id = active_pane.get(0).unwrap();
|
|
let pane_in_copy_mode = active_pane.get(1).unwrap().to_string();
|
|
|
|
self.active_pane_id = Some(pane_id.to_string());
|
|
self.active_pane_in_copy_mode = Some(pane_in_copy_mode);
|
|
|
|
if self.active_pane_in_copy_mode.clone().unwrap() == "1" {
|
|
let pane_height = active_pane
|
|
.get(2)
|
|
.unwrap()
|
|
.parse()
|
|
.expect("Unable to retrieve pane height");
|
|
let pane_scroll_position = active_pane
|
|
.get(3)
|
|
.unwrap()
|
|
.parse()
|
|
.expect("Unable to retrieve pane scroll");
|
|
|
|
self.active_pane_height = Some(pane_height);
|
|
self.active_pane_scroll_position = Some(pane_scroll_position);
|
|
}
|
|
}
|
|
|
|
pub fn execute_thumbs(&mut self) {
|
|
let options_command = vec!["tmux", "show", "-g"];
|
|
let params: Vec<String> = options_command.iter().map(|arg| arg.to_string()).collect();
|
|
let options = self.executor.execute(params);
|
|
let lines: Vec<&str> = options.split('\n').collect();
|
|
|
|
let pattern = Regex::new(r#"@thumbs-([\w\-0-9]+) "?(\w+)"?"#).unwrap();
|
|
|
|
let args = lines
|
|
.iter()
|
|
.flat_map(|line| {
|
|
if let Some(captures) = pattern.captures(line) {
|
|
let name = captures.get(1).unwrap().as_str();
|
|
let value = captures.get(2).unwrap().as_str();
|
|
|
|
let boolean_params = vec!["reverse", "unique", "contrast"];
|
|
|
|
if boolean_params.iter().any(|&x| x == name) {
|
|
return vec![format!("--{}", name)];
|
|
}
|
|
|
|
let string_params = vec![
|
|
"position",
|
|
"fg-color",
|
|
"bg-color",
|
|
"hint-bg-color",
|
|
"hint-fg-color",
|
|
"select-fg-color",
|
|
"select-bg-color",
|
|
];
|
|
|
|
if string_params.iter().any(|&x| x == name) {
|
|
return vec![format!("--{}", name), format!("'{}'", value)];
|
|
}
|
|
|
|
if name.starts_with("regexp") {
|
|
return vec!["--regexp".to_string(), format!("'{}'", value)];
|
|
}
|
|
|
|
vec![]
|
|
} else {
|
|
vec![]
|
|
}
|
|
})
|
|
.collect::<Vec<String>>();
|
|
|
|
let active_pane_id = self.active_pane_id.as_mut().unwrap().clone();
|
|
|
|
let scroll_params = if self.active_pane_in_copy_mode.is_some() {
|
|
if let (Some(pane_height), Some(scroll_position)) = (
|
|
self.active_pane_scroll_position,
|
|
self.active_pane_scroll_position,
|
|
) {
|
|
format!(
|
|
" -S {} -E {}",
|
|
-scroll_position,
|
|
pane_height - scroll_position - 1
|
|
)
|
|
} else {
|
|
"".to_string()
|
|
}
|
|
} else {
|
|
"".to_string()
|
|
};
|
|
|
|
// NOTE: For debugging add echo $PWD && sleep 5 after tee
|
|
let pane_command = format!(
|
|
"tmux capture-pane -t {active_id} -p{scroll_params} | target/release/thumbs -f '%U:%H' -t {tmpfile} {args}; tmux swap-pane -t {active_id}; tmux wait-for -S {signal}",
|
|
active_id = active_pane_id,
|
|
scroll_params = scroll_params,
|
|
// dir = self.directory.to_str().unwrap(),
|
|
tmpfile = TMP_FILE,
|
|
args = args.join(" "),
|
|
signal = self.signal
|
|
);
|
|
|
|
let thumbs_command = vec![
|
|
"tmux",
|
|
"new-window",
|
|
"-P",
|
|
"-d",
|
|
"-n",
|
|
"[thumbs]",
|
|
pane_command.as_str(),
|
|
];
|
|
|
|
let params: Vec<String> = thumbs_command.iter().map(|arg| arg.to_string()).collect();
|
|
|
|
self.thumbs_pane_id = Some(self.executor.execute(params));
|
|
}
|
|
|
|
pub fn swap_panes(&mut self) {
|
|
let active_pane_id = self.active_pane_id.as_mut().unwrap().clone();
|
|
let thumbs_pane_id = self.thumbs_pane_id.as_mut().unwrap().clone();
|
|
|
|
let swap_command = vec![
|
|
"tmux",
|
|
"swap-pane",
|
|
"-d",
|
|
"-s",
|
|
active_pane_id.as_str(),
|
|
"-t",
|
|
thumbs_pane_id.as_str(),
|
|
];
|
|
let params = swap_command.iter().map(|arg| arg.to_string()).collect();
|
|
|
|
self.executor.execute(params);
|
|
}
|
|
|
|
pub fn wait_thumbs(&mut self) {
|
|
let wait_command = vec!["tmux", "wait-for", self.signal.as_str()];
|
|
let params = wait_command.iter().map(|arg| arg.to_string()).collect();
|
|
|
|
self.executor.execute(params);
|
|
}
|
|
|
|
pub fn retrieve_content(&mut self) {
|
|
let retrieve_command = vec!["cat", TMP_FILE];
|
|
let params = retrieve_command.iter().map(|arg| arg.to_string()).collect();
|
|
|
|
self.content = Some(self.executor.execute(params));
|
|
}
|
|
|
|
pub fn destroy_content(&mut self) {
|
|
let retrieve_command = vec!["rm", TMP_FILE];
|
|
let params = retrieve_command.iter().map(|arg| arg.to_string()).collect();
|
|
|
|
self.executor.execute(params);
|
|
}
|
|
|
|
pub fn execute_command(&mut self) {
|
|
let content = self.content.clone().unwrap();
|
|
let mut splitter = content.splitn(2, ':');
|
|
|
|
if let Some(upcase) = splitter.next() {
|
|
if let Some(text) = splitter.next() {
|
|
let execute_command = if upcase.trim_end() == "true" {
|
|
self.alt_command.clone()
|
|
} else {
|
|
self.command.clone()
|
|
};
|
|
|
|
let final_command = str::replace(execute_command, "{}", text.trim_end());
|
|
let retrieve_command = vec!["bash", "-c", final_command.as_str()];
|
|
let params = retrieve_command.iter().map(|arg| arg.to_string()).collect();
|
|
|
|
self.executor.execute(params);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
struct TestShell {
|
|
outputs: Vec<String>,
|
|
executed: Option<Vec<String>>,
|
|
}
|
|
|
|
impl TestShell {
|
|
fn new(outputs: Vec<String>) -> TestShell {
|
|
TestShell {
|
|
executed: None,
|
|
outputs,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Executor for TestShell {
|
|
fn execute(&mut self, args: Vec<String>) -> String {
|
|
self.executed = Some(args);
|
|
self.outputs.pop().unwrap()
|
|
}
|
|
|
|
fn last_executed(&self) -> Option<Vec<String>> {
|
|
self.executed.clone()
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn retrieve_active_pane() {
|
|
let last_command_outputs =
|
|
vec!["%97:100:24:1:active\n%106:100:24:1:nope\n%107:100:24:1:nope\n".to_string()];
|
|
let mut executor = TestShell::new(last_command_outputs);
|
|
let mut swapper = Swapper::new(Box::new(&mut executor), "", "");
|
|
|
|
swapper.capture_active_pane();
|
|
|
|
assert_eq!(swapper.active_pane_id.unwrap(), "%97");
|
|
}
|
|
|
|
#[test]
|
|
fn swap_panes() {
|
|
let last_command_outputs = vec![
|
|
"".to_string(),
|
|
"%100".to_string(),
|
|
"".to_string(),
|
|
"%106:100:24:1:nope\n%98:100:24:1:active\n%107:100:24:1:nope\n".to_string(),
|
|
];
|
|
let mut executor = TestShell::new(last_command_outputs);
|
|
let mut swapper = Swapper::new(Box::new(&mut executor), "", "");
|
|
|
|
swapper.capture_active_pane();
|
|
swapper.execute_thumbs();
|
|
swapper.swap_panes();
|
|
|
|
let expectation = vec!["tmux", "swap-pane", "-d", "-s", "%98", "-t", "%100"];
|
|
|
|
assert_eq!(executor.last_executed().unwrap(), expectation);
|
|
}
|
|
}
|
|
|
|
/// Main configuration, parsed from command line.
|
|
#[derive(Clap, Debug)]
|
|
#[clap(author, about, version)]
|
|
struct BridgeOpt {
|
|
/// Command to execute on selection.
|
|
#[clap(long, default_value = "tmux set-buffer {}")]
|
|
command: String,
|
|
|
|
/// Command to execute on uppercased selection.
|
|
#[clap(long, default_value = "tmux set-buffer {} && tmux-paste-buffer")]
|
|
alt_command: String,
|
|
|
|
/// Retrieve options from tmux.
|
|
///
|
|
/// If active, options formatted like `copyrat-*` are read from tmux.
|
|
/// You should consider reading them from the config file (the default
|
|
/// option) as this saves both a command call (about 10ms) and a Regex
|
|
/// compilation.
|
|
#[clap(short = "T", long)]
|
|
get_options_from_tmux: bool,
|
|
|
|
/// Optionally capture entire pane history.
|
|
#[clap(long, arg_enum, default_value = "entire-history")]
|
|
capture: tmux::CaptureRegion,
|
|
|
|
// Include CLI Options
|
|
#[clap(flatten)]
|
|
cli_options: CliOpt,
|
|
}
|
|
|
|
impl BridgeOpt {
|
|
/// Try parsing provided options, and update self with the valid values.
|
|
pub fn merge_map(
|
|
&mut self,
|
|
options: &HashMap<String, String>,
|
|
) -> Result<(), error::ParseError> {
|
|
for (name, value) in options {
|
|
match name.as_ref() {
|
|
"@copyrat-command" => {
|
|
self.command = String::from(value);
|
|
}
|
|
"@copyrat-alt-command" => {
|
|
self.alt_command = String::from(value);
|
|
}
|
|
"@copyrat-capture" => {
|
|
self.capture = tmux::CaptureRegion::from_str(&value)?;
|
|
}
|
|
|
|
// Ignore unknown options.
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
// Pass the call to cli_options.
|
|
self.cli_options.merge_map(options)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn main() -> Result<(), error::ParseError> {
|
|
let mut opt = BridgeOpt::parse();
|
|
|
|
if opt.get_options_from_tmux {
|
|
let tmux_options = tmux::get_options("@copyrat-")?;
|
|
opt.merge_map(&tmux_options)?;
|
|
}
|
|
|
|
let panes: Vec<tmux::Pane> = tmux::list_panes()?;
|
|
|
|
let active_pane = panes
|
|
.iter()
|
|
.find(|p| p.is_active)
|
|
.expect("One tmux pane should be active");
|
|
|
|
let buffer = tmux::capture_pane(&active_pane, &opt.capture)?;
|
|
|
|
let selections: Vec<(String, bool)> = if active_pane.in_mode {
|
|
// If the current pane is in copy mode, we have to dance a little with
|
|
// Panes, because the current pane has already locked the Alternate
|
|
// Screen, preventing copyrat::run to execute.
|
|
let initial_pane = active_pane;
|
|
|
|
// Create a new window without switching to it, with a `sh` command
|
|
// for faster startup.
|
|
let temp_pane: tmux::Pane = tmux::create_new_window("[copyrat]", "sh")?;
|
|
|
|
// Swap the two panes, changing the active pane to be the temp_pane.
|
|
// After swap, temp_pane has the same height than the initial_pane
|
|
// had before being swapped.
|
|
tmux::swap_panes(initial_pane, &temp_pane)?;
|
|
|
|
// Running copyrat now will render in the newly created temp_pane
|
|
// (locking stdin, writing to its stdout), but this is almost
|
|
// transparent to the user.
|
|
let selections = copyrat::run(buffer, &opt.cli_options);
|
|
|
|
// Swap back the two panes, making initial_pane the active one again.
|
|
tmux::swap_panes(&temp_pane, initial_pane)?;
|
|
|
|
tmux::kill_pane(&temp_pane)?;
|
|
|
|
selections
|
|
} else {
|
|
copyrat::run(buffer, &opt.cli_options)
|
|
};
|
|
|
|
// Execute a command on each selection.
|
|
// TODO: consider getting rid of multi-selection mode.
|
|
selections.iter().for_each(|(text, uppercased)| {
|
|
let raw_command = if *uppercased {
|
|
opt.alt_command.replace("{}", text)
|
|
} else {
|
|
opt.command.replace("{}", text)
|
|
};
|
|
let mut it = raw_command.split(' ').into_iter();
|
|
let command = it.next().unwrap();
|
|
let args: Vec<&str> = it.collect();
|
|
|
|
// Simply execute the command as is, and let the program crash on
|
|
// potential errors because it is not our responsibility.
|
|
process::execute(&command, &args).unwrap();
|
|
});
|
|
|
|
if false {
|
|
let mut executor = RealShell::new();
|
|
|
|
let mut swapper = Swapper::new(
|
|
Box::new(&mut executor),
|
|
// opt.directory.as_path(),
|
|
&opt.command,
|
|
&opt.alt_command,
|
|
);
|
|
|
|
swapper.capture_active_pane();
|
|
swapper.execute_thumbs();
|
|
swapper.swap_panes();
|
|
swapper.wait_thumbs();
|
|
swapper.retrieve_content();
|
|
swapper.destroy_content();
|
|
swapper.execute_command();
|
|
}
|
|
|
|
Ok(())
|
|
}
|