stonewareslord/rust-selection-sort.kak
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactor kak code to kakplugin

Browse Source
This commit is contained in:
Austen Adler 2022-06-05 00:59:05 -04:00
parent 3d867c7f0d
commit f1e326fbd7
11 changed files with 95 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
kakplugin/src/errors.rs
View File

@ -12,7 +12,43 @@ pub enum KakError {
KakResponse(String),
/// IO Error
Io(std::io::Error),
/// Not yet implemented
NotImplemented(&'static str),
/// Custom error string
Custom(String),
}
impl KakError {
pub fn details(&self) -> String {
match self {
Self::EnvVarNotSet(e) => e.clone(),
Self::EnvVarUnicode(e) => e.clone(),
Self::Parse(e) => e.clone(),
Self::KakResponse(e) => e.clone(),
Self::Io(e) => format!("{e:?}"),
Self::NotImplemented(e) => e.to_string(),
Self::Custom(s) => s.clone(),
}
}
}
impl ToString for KakError {
fn to_string(&self) -> String {
format!(
"Error: {}",
match self {
Self::EnvVarNotSet(_) => "env var not set",
Self::EnvVarUnicode(_) => "env var not unicode",
Self::Parse(_) => "Could not parse",
Self::KakResponse(_) => "Invalid kak response",
Self::Io(_) => "IO error",
Self::NotImplemented(_) => "Not Implemented",
Self::Custom(s) => &s,
}
)
}
}
impl From<std::io::Error> for KakError {
fn from(e: std::io::Error) -> Self {
Self::Io(e)

7
kakplugin/src/lib.rs
View File

@ -127,7 +127,10 @@ where
/// # Errors
///
/// Will return `Err` if command fifo could not be opened, read from, or written to
pub fn send_message<S: AsRef<str>>(message: S, debug_message: Option<S>) -> Result<(), KakError> {
pub fn display_message<S: AsRef<str>>(
message: S,
debug_message: Option<S>,
) -> Result<(), KakError> {
let msg_str = message.as_ref().replace('\'', "''");
{
let mut f = open_command_fifo()?;
@ -186,7 +189,7 @@ pub fn open_command_fifo() -> Result<BufWriter<File>, KakError> {
/// # Errors
///
/// Will return `Err` if requested environment variable is not unicode or not present
fn get_var(var_name: &str) -> Result<String, KakError> {
pub fn get_var(var_name: &str) -> Result<String, KakError> {
env::var(var_name).map_err(|e| match e {
env::VarError::NotPresent => {
KakError::EnvVarNotSet(format!("Env var {} is not defined", var_name))

333
src/kak.rs
View File

@ -1,333 +0,0 @@
use crate::{get_var, KakMessage};
// use shellwords::ShellWordsIterator;
use std::{
fmt,
fs::{self, File, OpenOptions},
io::{BufWriter, Write},
str::FromStr,
};
pub type Selection = String;
#[derive(PartialEq, Eq, Debug)]
pub struct SelectionWithDesc {
pub content: Selection,
pub desc: SelectionDesc,
}
#[derive(PartialEq, Eq, Debug)]
pub struct SelectionWithSubselections {
pub selection: SelectionWithDesc,
pub subselections: Vec<SelectionWithDesc>,
}
#[derive(PartialEq, PartialOrd, Ord, Eq, Debug)]
pub struct SelectionDesc {
pub left: AnchorPosition,
pub right: AnchorPosition,
}
impl SelectionDesc {
#[must_use]
pub fn sort(&self) -> Self {
if self.left < self.right {
// left anchor is first
Self {
left: self.left.clone(),
right: self.right.clone(),
}
} else {
// right anchor is first
Self {
left: self.right.clone(),
right: self.left.clone(),
}
}
}
#[must_use]
pub fn contains(&self, b: &Self) -> bool {
// Cursor and anchor can be flipped. Set a.0 to be leftmost cursor
let sorted_a = self.sort();
let sorted_b = b.sort();
sorted_b.left >= sorted_a.left && sorted_b.right <= sorted_a.right
}
}
impl fmt::Display for SelectionDesc {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{},{}", self.left, self.right)
}
}
impl FromStr for SelectionDesc {
type Err = KakMessage;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let (left, right) = s.split_once(',').ok_or_else(|| {
KakMessage(
"Could not parse position".to_string(),
Some(format!("Could not parse as position: {}", s)),
)
})?;
Ok(Self {
left: AnchorPosition::from_str(left)?,
right: AnchorPosition::from_str(right)?,
})
}
}
#[derive(PartialOrd, PartialEq, Clone, Eq, Ord, Debug)]
pub struct AnchorPosition {
pub row: usize,
pub col: usize,
}
impl fmt::Display for AnchorPosition {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}.{}", self.row, self.col)
}
}
impl FromStr for AnchorPosition {
type Err = KakMessage;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let (left, right) = s.split_once('.').ok_or_else(|| {
KakMessage(
"Could not parse position".to_string(),
Some(format!("Could not parse as position: {}", s)),
)
})?;
Ok(Self {
row: usize::from_str(left)?,
col: usize::from_str(right)?,
})
}
}
/// # Errors
///
/// Will return `Err` if command fifo could not be opened, read from, or written to
pub fn get_selections() -> Result<Vec<Selection>, KakMessage> {
response("%val{selections}")
}
/// # Errors
///
/// Will return `Err` if command fifo could not be opened, read from, or written to
pub fn get_selections_desc() -> Result<Vec<SelectionDesc>, KakMessage> {
response("%val{selections_desc}")?
.iter()
.map(|sd| SelectionDesc::from_str(sd))
.collect::<Result<Vec<_>, KakMessage>>()
}
// pub fn get_selections_with_subselections(
// register: &str,
// ) -> Result<Vec<SelectionWithSubselections>, KakMessage> {
// // TODO: Escape register
// let subselections = get_selections_with_desc()?;
// exec(format!("\"{}z", register.replace('\'', "''")))?;
// let selections = get_selections_with_desc()?;
// for sel in selections {
// for i in subselections {}
// }
// }
/// # Errors
///
/// Will return `Err` if command fifo could not be opened, read from, or written to,
/// or if `selections.len() != selections_desc.len`
pub fn get_selections_with_desc() -> Result<Vec<SelectionWithDesc>, KakMessage> {
let mut selections = get_selections()?;
let selections_desc = get_selections_desc()?;
if selections.len() != selections_desc.len() {
return Err(KakMessage(
"Internal error".to_string(),
Some(format!(
"Counts for selections={}, selections_desc={}",
selections.len(),
selections_desc.len()
)),
));
}
// Kakoune prints selections in file order, but prints selections_desc rotated based on current selection
let min_selection = selections_desc.iter().min().ok_or_else(|| {
KakMessage(
"Internal error".to_string(),
Some("No selections in selections_desc".to_string()),
)
})?;
// Need to rotate selections by primary selection's position in the list
match selections_desc.iter().position(|p| p == min_selection) {
Some(i) => {
selections.rotate_right(i);
}
None => {
return Err(KakMessage(
"Internal error".to_string(),
Some(format!(
"Primary selection {} not found in selection_desc list ({:#?})",
min_selection, selections_desc
)),
))
}
}
selections
.into_iter()
.zip(selections_desc.into_iter())
.map(|(content, desc)| Ok(SelectionWithDesc { content, desc }))
.collect::<Result<Vec<_>, _>>()
}
/// # Errors
///
/// Will return `Err` if command fifo could not be opened, read from, or written to
pub fn set_selections<'a, I, S: 'a + ?Sized>(selections: I) -> Result<(), KakMessage>
where
I: IntoIterator<Item = &'a S>,
S: AsRef<str> + fmt::Display,
{
let mut f = open_command_fifo()?;
write!(f, "reg '\"'")?;
for i in selections {
write!(f, " '{}'", i.as_ref().replace('\'', "''"))?;
}
write!(f, "; exec R;")?;
f.flush()?;
Ok(())
}
/// # Errors
///
/// Will return `Err` if command fifo could not be opened, read from, or written to
pub fn set_selections_desc<'a, I>(selections: I) -> Result<(), KakMessage>
where
I: IntoIterator<Item = &'a SelectionDesc>,
{
let mut f = open_command_fifo()?;
write!(f, "select")?;
for i in selections {
write!(f, " {}", i)?;
}
write!(f, ";")?;
f.flush()?;
Ok(())
}
/// # Errors
///
/// Will return `Err` if command fifo could not be opened, read from, or written to
pub fn send_message(msg: &KakMessage) -> Result<(), Box<dyn std::error::Error>> {
let msg_str = msg.0.replace('\'', "''");
{
let mut f =
open_command_fifo().map_err(|e| format!("Could not open command fifo: {:?}", e))?;
write!(f, "echo '{}';", msg_str)?;
write!(f, "echo -debug '{}';", msg_str)?;
if let Some(debug_msg_str) = &msg.1 {
write!(f, "echo -debug '{}';", debug_msg_str.replace('\'', "''"))?;
}
f.flush()?;
}
Ok(())
}
/// # Errors
///
/// Will return `Err` if command fifo could not be opened or written to
pub fn exec(cmd: &str) -> Result<(), KakMessage> {
let mut f = open_command_fifo()?;
write!(f, "{}", cmd)?;
f.flush().map_err(Into::into)
}
/// # Errors
///
/// Will return `Err` if command fifo could not be opened or written to
pub fn response(msg: &str) -> Result<Vec<String>, KakMessage> {
exec(&format!(
"echo -quoting shell -to-file {} -- {msg}",
get_var("kak_response_fifo")?
))?;
let selections = shellwords::split(&fs::read_to_string(&get_var("kak_response_fifo")?)?)?;
Ok(selections)
}
// pub fn response_iter(msg: &str) -> Result<ShellWordsIterator, KakMessage> {
// exec(&format!(
// "echo -quoting shell -to-file {} -- {msg}",
// get_var("kak_response_fifo")?
// ))?;
// Ok(shellwords::split_iter(&fs::read_to_string(&get_var(
// "kak_response_fifo",
// )?)?))
// }
/// # Errors
///
/// Will return `Err` if command fifo could not be opened
pub fn open_command_fifo() -> Result<BufWriter<File>, KakMessage> {
OpenOptions::new()
.write(true)
.append(true)
.open(&get_var("kak_command_fifo")?)
.map(BufWriter::new)
.map_err(Into::into)
}
#[cfg(test)]
mod test {
use super::*;
const SD: SelectionDesc = SelectionDesc {
left: AnchorPosition { row: 18, col: 9 },
right: AnchorPosition { row: 10, col: 1 },
};
#[test]
fn test_anchor_position() {
// Check parsing
assert_eq!(SelectionDesc::from_str("18.9,10.1").unwrap(), SD);
// Check if multiple parsed ones match
assert_eq!(
SelectionDesc::from_str("18.9,10.1").unwrap(),
SelectionDesc::from_str("18.9,10.1").unwrap()
);
}
#[test]
fn test_sort() {
// Check if sorting works
assert_eq!(SD.sort(), SelectionDesc::from_str("10.1,18.9").unwrap());
assert_eq!(SD.sort(), SD.sort().sort());
}
#[test]
fn test_contains() {
assert!(SD.contains(&SD));
assert!(SD.contains(&SelectionDesc::from_str("17.9,10.1").unwrap()));
assert!(SD.contains(&SelectionDesc::from_str("18.8,10.1").unwrap()));
assert!(SD.contains(&SelectionDesc::from_str("18.9,11.1").unwrap()));
assert!(SD.contains(&SelectionDesc::from_str("18.9,10.2").unwrap()));
assert!(SD.contains(&SelectionDesc::from_str("10.1,17.9").unwrap()));
assert!(SD.contains(&SelectionDesc::from_str("10.1,18.8").unwrap()));
assert!(SD.contains(&SelectionDesc::from_str("11.1,18.9").unwrap()));
assert!(SD.contains(&SelectionDesc::from_str("10.2,18.9").unwrap()));
assert!(!SD.contains(&SelectionDesc::from_str("19.9,10.1").unwrap()));
assert!(!SD.contains(&SelectionDesc::from_str("18.10,10.1").unwrap()));
assert!(!SD.contains(&SelectionDesc::from_str("18.9,9.1").unwrap()));
assert!(!SD.contains(&SelectionDesc::from_str("18.9,10.0").unwrap()));
assert!(!SD.contains(&SelectionDesc::from_str("10.1,19.9").unwrap()));
assert!(!SD.contains(&SelectionDesc::from_str("10.1,18.10").unwrap()));
assert!(!SD.contains(&SelectionDesc::from_str("9.1,18.9").unwrap()));
assert!(!SD.contains(&SelectionDesc::from_str("10.0,18.9").unwrap()));
}
}

51
src/main.rs
View File

@ -6,9 +6,6 @@
#![allow(clippy::multiple_crate_versions)]
#![allow(clippy::struct_excessive_bools)]
// #![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::cargo)]
// #![allow(dead_code, unused_imports)]
mod errors;
mod kak;
mod math_eval;
@ -19,9 +16,8 @@ mod trim;
mod uniq;
mod xargs;
use clap::{Parser, Subcommand};
use errors::KakMessage;
pub use kak::*;
use std::env;
use kakplugin::{display_message, get_var, KakError};
#[derive(Parser, Debug)]
#[clap(about, version, author)]
@ -55,31 +51,22 @@ fn main() {
panic!("Environment variable kak_command_fifo and kak_response_fifo must be set");
}
let msg = match run() {
Ok(msg) => msg,
Err(msg) => {
// TODO: Do not do a string allocation here
eprintln!(
"{} (Debug info: {})",
msg.0,
msg.1.as_ref().map_or("", String::as_str)
);
msg
}
let (msg, msg_details) = match run() {
Ok(msg) => (msg, None),
Err(e) => (e.to_string(), Some(e.details())),
};
if let Err(e) = send_message(&msg) {
println!("{}", e);
if let Err(display_error) = display_message(&msg, msg_details.as_ref()) {
// If there was an error sending the display message to kakoune, print it out
eprintln!(
"Error sending message '{msg:?}' (details: '{msg_details:?}') to kak: {display_error:?}"
);
}
}
fn run() -> Result<KakMessage, KakMessage> {
let options = Cli::try_parse().map_err(|e| {
KakMessage(
"Error parsing arguments".to_string(),
Some(format!("Could not parse: {}", e)),
)
})?;
fn run() -> Result<String, KakError> {
let options =
Cli::try_parse().map_err(|e| KakError::Parse(format!("Argument parse error: {e}")))?;
match &options.command {
Commands::Sort(o) => sort::sort(o),
@ -91,17 +78,3 @@ fn run() -> Result<KakMessage, KakMessage> {
Commands::Stdin(o) => stdin::stdin(o),
}
}
/// # Errors
///
/// Will return `Err` if requested environment variable is not unicode or not present
pub fn get_var(var_name: &str) -> Result<String, KakMessage> {
env::var(var_name).map_err(|e| match e {
env::VarError::NotPresent => {
KakMessage(format!("Env var {} is not defined", var_name), None)
}
env::VarError::NotUnicode(_) => {
KakMessage(format!("Env var {} is not unicode", var_name), None)
}
})
}

9
src/math_eval.rs
View File

@ -1,10 +1,10 @@
use crate::{get_selections, open_command_fifo, KakMessage};
use evalexpr::{eval, Value};
use kakplugin::{get_selections, open_command_fifo, KakError};
use std::io::Write;
#[derive(clap::StructOpt, Debug)]
pub struct Options;
pub fn math_eval(_options: &Options) -> Result<KakMessage, KakMessage> {
pub fn math_eval(_options: &Options) -> Result<String, KakError> {
let selections = get_selections()?;
let mut f = open_command_fifo()?;
@ -38,8 +38,5 @@ pub fn math_eval(_options: &Options) -> Result<KakMessage, KakMessage> {
write!(f, " ; exec R;")?;
f.flush()?;
Ok(KakMessage(
format!("MathEval {} selections", selections.len()),
None,
))
Ok(format!("MathEval {} selections", selections.len()))
}

9
src/shuf.rs
View File

@ -1,8 +1,8 @@
use crate::{get_selections, set_selections, KakMessage};
use kakplugin::{get_selections, set_selections, KakError};
use rand::{seq::SliceRandom, thread_rng};
#[derive(clap::StructOpt, Debug)]
pub struct Options;
pub fn shuf(_options: &Options) -> Result<KakMessage, KakMessage> {
pub fn shuf(_options: &Options) -> Result<String, KakError> {
let mut selections = get_selections()?;
let mut rng = thread_rng();
@ -10,8 +10,5 @@ pub fn shuf(_options: &Options) -> Result<KakMessage, KakMessage> {
set_selections(selections.iter())?;
Ok(KakMessage(
format!("Shuf {} selections", selections.len()),
None,
))
Ok(format!("Shuf {} selections", selections.len()))
}

24
src/sort.rs
View File

@ -1,5 +1,5 @@
use crate::{get_selections_with_desc, kak, open_command_fifo, KakMessage, SelectionWithDesc};
use alphanumeric_sort::compare_str;
use kakplugin::{self, get_selections_with_desc, open_command_fifo, KakError, SelectionWithDesc};
use regex::Regex;
use std::{cmp::Ordering, io::Write};
@ -117,15 +117,15 @@ fn to_sortable_selection<'a, 'b>(
}
}
pub fn sort(options: &Options) -> Result<KakMessage, KakMessage> {
pub fn sort(options: &Options) -> Result<String, KakError> {
// subselections is Some if the user requests it in subselections_register
// It will "exec z" to restore the selections before setting selections
// If subselections is None, "exec z" is not called
let subselections: Option<Vec<SelectionWithDesc>> = options
.subselections_register
.map::<Result<_, KakMessage>, _>(|c| {
.map::<Result<_, KakError>, _>(|c| {
let subselections = get_selections_with_desc()?;
kak::exec(&format!("exec {}", c))?;
kakplugin::exec(&format!("exec {}", c))?;
Ok(subselections)
})
.transpose()?;
@ -133,9 +133,9 @@ pub fn sort(options: &Options) -> Result<KakMessage, KakMessage> {
let mut zipped: Vec<SortableSelection<'_>> = match (&options.regex, &subselections) {
(Some(_), Some(_)) => {
return Err("Cannot pass regex and subselections register"
.to_string()
.into())
return Err(KakError::Custom(
"Cannot pass regex and subselections register".to_string(),
))
}
(None, None) => {
// Do a regular sort on the content
@ -166,9 +166,8 @@ pub fn sort(options: &Options) -> Result<KakMessage, KakMessage> {
}
(None, _) => {
// Sort based on subselections
return Err(KakMessage(
"Not yet implemented".to_string(),
Some("Sort by subselection is not yet implemented".to_string()),
return Err(KakError::NotImplemented(
"Sort by subselection is not yet implemented",
));
}
};
@ -212,8 +211,5 @@ pub fn sort(options: &Options) -> Result<KakMessage, KakMessage> {
write!(f, " ; exec R;")?;
f.flush()?;
Ok(KakMessage(
format!("Sorted {} selections", zipped.len()),
None,
))
Ok(format!("Sorted {} selections", zipped.len()))
}

10
src/stdin.rs
View File

@ -1,4 +1,4 @@
use crate::{get_selections_with_desc, set_selections, KakMessage};
use kakplugin::{get_selections_with_desc, set_selections, KakError};
use std::{
io::{BufRead, BufReader, Write},
process::{Command, Stdio},
@ -8,7 +8,7 @@ pub struct Options {
command: String,
args: Vec<String>,
}
pub fn stdin(options: &Options) -> Result<KakMessage, KakMessage> {
pub fn stdin(options: &Options) -> Result<String, KakError> {
let mut child = Command::new(&options.command)
.args(&options.args)
.stdin(Stdio::piped())
@ -17,7 +17,7 @@ pub fn stdin(options: &Options) -> Result<KakMessage, KakMessage> {
.expect("Failed to spawn child process");
let mut child_stdin = child.stdin.take().expect("Failed to open stdin");
let handle = std::thread::spawn(move || -> Result<(), KakMessage> {
let handle = std::thread::spawn(move || -> Result<(), KakError> {
for s in get_selections_with_desc()? {
eprintln!("Got selection {}", s.content);
write!(child_stdin, "{}\0", s.content)?;
@ -29,7 +29,7 @@ pub fn stdin(options: &Options) -> Result<KakMessage, KakMessage> {
BufReader::new(child.stdout.take().expect("Failed to get stdout"))
.split(b'\0')
.map(|s| Ok(String::from_utf8_lossy(&s?).into_owned()))
.collect::<Result<Vec<_>, KakMessage>>()?
.collect::<Result<Vec<_>, KakError>>()?
.iter(),
)?;
@ -37,7 +37,7 @@ pub fn stdin(options: &Options) -> Result<KakMessage, KakMessage> {
// TODO: Do not use a string
handle
.join()
.map_err(|_e| String::from("Could not join background process"))??;
.map_err(|_e| KakError::Custom("Could not join background process".to_string()))??;
Ok("stdin selections".into())
}

13
src/trim.rs
View File

@ -1,4 +1,4 @@
use crate::{get_selections, open_command_fifo, KakMessage};
use kakplugin::{get_selections, open_command_fifo, KakError};
use std::io::Write;
#[derive(clap::StructOpt, Debug)]
@ -11,7 +11,7 @@ pub struct Options {
no_preserve_newline: bool,
}
pub fn trim(options: &Options) -> Result<KakMessage, KakMessage> {
pub fn trim(options: &Options) -> Result<String, KakError> {
let selections = get_selections()?;
let mut f = open_command_fifo()?;
@ -45,11 +45,8 @@ pub fn trim(options: &Options) -> Result<KakMessage, KakMessage> {
write!(f, " ; exec R;")?;
f.flush()?;
Ok(KakMessage(
format!(
"Trimmed {} selections ({} changed)",
num_selections, num_trimmed
),
None,
Ok(format!(
"Trimmed {} selections ({} changed)",
num_selections, num_trimmed
))
}

6
src/uniq.rs
View File

@ -34,6 +34,7 @@ pub fn uniq(options: &Options) -> Result<String, KakError> {
s.content.trim()
};
// If they requested a regex match, set the key to the string slice of that match
if let Some(regex_match) = (|| {
let captures = options.regex.as_ref()?.captures(key)?;
captures
@ -67,12 +68,9 @@ pub fn uniq(options: &Options) -> Result<String, KakError> {
})
.collect();
// Preallocate so the content and string have the same type, but allocation is not repeated
// TODO: Do we really have to do this?
let empty_string = String::default();
set_selections(new_selections.iter().map(|i| match i {
Some(s) => &s.content,
None => &empty_string,
None => "",
}))?;
// Deselect all `None` strings (all rows that have been seen before)

23
src/xargs.rs
View File

@ -1,4 +1,4 @@
use crate::{get_selections_with_desc, set_selections, KakMessage};
use kakplugin::{get_selections_with_desc, set_selections, KakError};
use std::{
io::{BufRead, BufReader, Write},
process::{Command, Stdio},
@ -7,7 +7,7 @@ use std::{
pub struct Options {
args: Vec<String>,
}
pub fn xargs(options: &Options) -> Result<KakMessage, KakMessage> {
pub fn xargs(options: &Options) -> Result<String, KakError> {
let mut child = Command::new("xargs")
.arg("-0")
.arg("--")
@ -18,7 +18,7 @@ pub fn xargs(options: &Options) -> Result<KakMessage, KakMessage> {
.expect("Failed to spawn child process");
let mut stdin = child.stdin.take().expect("Failed to open stdin");
let handle = std::thread::spawn(move || -> Result<(), KakMessage> {
let handle = std::thread::spawn(move || -> Result<(), KakError> {
for s in get_selections_with_desc()? {
eprintln!("Got selection {}", s.content);
write!(stdin, "{}\0", s.content)?;
@ -29,18 +29,23 @@ pub fn xargs(options: &Options) -> Result<KakMessage, KakMessage> {
eprintln!("About t oreadvv");
set_selections(
BufReader::new(child.stdout.take().ok_or("Failed to get stdout")?)
.split(b'\0')
.map(|s| Ok(String::from_utf8_lossy(&s?).into_owned()))
.collect::<Result<Vec<_>, KakMessage>>()?
.iter(),
BufReader::new(
child
.stdout
.take()
.ok_or(KakError::Custom("Failed to get stdout".to_string()))?,
)
.split(b'\0')
.map(|s| Ok(String::from_utf8_lossy(&s?).into_owned()))
.collect::<Result<Vec<_>, KakError>>()?
.iter(),
)?;
// Wait for the background process to exit
// TODO: Do not use a string
handle
.join()
.map_err(|_e| "Could not join background process")??;
.map_err(|_e| KakError::Custom("Could not join background process".to_string()))??;
Ok("xargs selections".into())
}