forked from bonsai/harakit
140 lines
3.9 KiB
Rust
140 lines
3.9 KiB
Rust
/*
|
||
* Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
|
||
* SPDX-License-Identifier: AGPL-3.0-or-later
|
||
*
|
||
* This program is free software: you can redistribute it and/or modify it under
|
||
* the terms of the GNU Affero General Public License as published by the Free
|
||
* Software Foundation, either version 3 of the License, or (at your option) any
|
||
* later version.
|
||
*
|
||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
||
* FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
|
||
* details.
|
||
*
|
||
* You should have received a copy of the GNU Affero General Public License
|
||
* along with this program. If not, see https://www.gnu.org/licenses/.
|
||
*/
|
||
|
||
use std::{
|
||
env::args,
|
||
io::{ Read, stdin, stdout, Write },
|
||
process::{ Command, exit, Stdio },
|
||
};
|
||
|
||
extern crate getopt;
|
||
extern crate strerror;
|
||
extern crate sysexits;
|
||
|
||
use getopt::GetOpt;
|
||
use strerror::StrError;
|
||
use sysexits::{ EX_DATAERR, EX_IOERR, EX_UNAVAILABLE, EX_USAGE };
|
||
|
||
fn main() {
|
||
let argv = args().collect::<Vec<String>>();
|
||
let mut d = '\u{1E}'.to_string(); /* ASCII record separator */
|
||
let mut optind = 0;
|
||
|
||
let usage = format!(
|
||
"Usage: {} [-d delimiter] index command [args...]",
|
||
argv[0],
|
||
);
|
||
|
||
while let Some(opt) = argv.getopt("d:") {
|
||
match opt.opt() {
|
||
Ok(_) => {
|
||
/* delimiter */
|
||
d = opt.arg().unwrap();
|
||
optind = opt.ind();
|
||
},
|
||
Err(_) => {
|
||
eprintln!("{}", usage);
|
||
exit(EX_USAGE);
|
||
}
|
||
};
|
||
}
|
||
|
||
/* index of the argv[0] for the operator command */
|
||
let command_arg = optind as usize + 1;
|
||
|
||
/* argv[0] of the operator command */
|
||
let operator = argv.get(command_arg).unwrap_or_else(|| {
|
||
eprintln!("{}", usage);
|
||
exit(EX_USAGE);
|
||
});
|
||
|
||
/* parse the specified index as a number we can use */
|
||
let index = argv[optind].parse::<usize>().unwrap_or_else(|e| {
|
||
eprintln!("{}: {}: {}", argv[0], argv[1], e);
|
||
exit(EX_DATAERR);
|
||
});
|
||
|
||
let mut buf = String::new();
|
||
let _ = stdin().read_to_string(&mut buf);
|
||
|
||
/* split the buffer by the delimiter (by default, '\u{1E}') */
|
||
let mut fields = buf.split(&d).collect::<Vec<&str>>();
|
||
|
||
/* collect arguments for the operator command */
|
||
let opts = argv
|
||
.iter()
|
||
.clone()
|
||
.skip(command_arg + 1) /* skip the command name */
|
||
.collect::<Vec<&String>>();
|
||
|
||
/* spawn the command to operate on the field */
|
||
let mut spawned = Command::new(operator)
|
||
.args(opts) /* spawn with the specified arguments */
|
||
.stdin(Stdio::piped())
|
||
.stdout(Stdio::piped()) /* piped stdout to handle output ourselves */
|
||
.spawn()
|
||
.unwrap_or_else( |e| {
|
||
eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
|
||
exit(EX_UNAVAILABLE);
|
||
});
|
||
|
||
/* get field we want to pipe into spawned program */
|
||
let field = fields.get(index).unwrap_or_else(|| {
|
||
eprintln!(
|
||
"{}: {}: No such index in input",
|
||
argv[0],
|
||
index.to_string(),
|
||
);
|
||
exit(EX_DATAERR);
|
||
});
|
||
|
||
/* get the stdin of the newly spawned program and feed it the field val */
|
||
if let Some(mut child_stdin) = spawned.stdin.take() {
|
||
let _ = child_stdin.write_all(field.as_bytes());
|
||
drop(child_stdin); /* stay safe! drop your children! */
|
||
}
|
||
|
||
let output = spawned.wait_with_output().unwrap_or_else(|e| {
|
||
eprintln!("{}: {}: {}", argv[0], argv[command_arg], e.strerror());
|
||
exit(EX_IOERR);
|
||
});
|
||
|
||
/* get the output with which the original field will be replaced */
|
||
let mut replace = output.stdout.clone();
|
||
|
||
/* as long as it’s not a newline, set the replacement to the output */
|
||
if replace.pop() != Some(b'\n') { replace = output.stdout; }
|
||
|
||
/* convert the output of the program to UTF-8 */
|
||
let new_field = String::from_utf8(replace).unwrap_or_else(|e| {
|
||
eprintln!("{}: {}: {}", argv[0], argv[command_arg], e);
|
||
exit(EX_IOERR);
|
||
});
|
||
|
||
/* store the new field in the old fields vector */
|
||
fields[index] = &new_field;
|
||
|
||
/* fop it */
|
||
stdout().write_all(
|
||
fields.join(&d.to_string()).as_bytes()
|
||
).unwrap_or_else(|e| {
|
||
eprintln!("{}: {}", argv[0], e.strerror());
|
||
exit(EX_IOERR);
|
||
});
|
||
}
|