asp/keep
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: update dependencies and remove binary and command meta plugins

Browse Source
This commit is contained in:
Andrew Phillips
2025-08-28 13:11:19 -03:00
committed by Andrew Phillips (aider)
parent 40e4fcc74a
commit 52dc8cea32
5 changed files with 78 additions and 399 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
src/meta_plugin/binary.rs
View File

@@ -1,149 +0,0 @@
use crate::common::is_binary::is_binary;
use crate::common::PIPESIZE;
use crate::meta_plugin::{MetaPlugin, MetaPluginResponse, MetaPluginType};
#[derive(Debug, Clone, Default)]
pub struct BinaryMetaPlugin {
buffer: Vec<u8>,
max_buffer_size: usize,
is_finalized: bool,
base: crate::meta_plugin::BaseMetaPlugin,
}
impl BinaryMetaPlugin {
pub fn new(
options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
) -> BinaryMetaPlugin {
let mut base = crate::meta_plugin::BaseMetaPlugin::new();
// Initialize with helper function
base.initialize_plugin(
&["binary"],
options,
outputs,
);
let max_buffer_size = base.options.get("max_buffer_size")
.and_then(|v| v.as_u64())
.unwrap_or(PIPESIZE as u64) as usize;
BinaryMetaPlugin {
buffer: Vec::new(),
max_buffer_size,
is_finalized: false,
base,
}
}
}
impl MetaPlugin for BinaryMetaPlugin {
fn is_finalized(&self) -> bool {
self.is_finalized
}
fn set_finalized(&mut self, finalized: bool) {
self.is_finalized = finalized;
}
fn update(&mut self, data: &[u8]) -> MetaPluginResponse {
// If already finalized, don't process more data
if self.is_finalized {
return MetaPluginResponse {
metadata: Vec::new(),
is_finalized: true,
};
}
// Calculate how much data we can still accept
let remaining_capacity = self.max_buffer_size.saturating_sub(self.buffer.len());
if remaining_capacity > 0 {
// Determine how much data to copy
let bytes_to_take = std::cmp::min(data.len(), remaining_capacity);
// Add data to our buffer
self.buffer.extend_from_slice(&data[..bytes_to_take]);
}
// If we've reached our buffer limit, return metadata
let mut metadata = Vec::new();
if self.buffer.len() >= self.max_buffer_size {
let is_binary_result = is_binary(&self.buffer);
let value = if is_binary_result { "true".to_string() } else { "false".to_string() };
// Use process_metadata_outputs to handle output mapping
if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
"binary",
serde_yaml::Value::String(value),
self.base.outputs()
) {
metadata.push(meta_data);
}
// Mark as finalized
self.is_finalized = true;
}
let is_finalized = !metadata.is_empty();
MetaPluginResponse {
metadata,
is_finalized,
}
}
fn finalize(&mut self) -> MetaPluginResponse {
// If already finalized, don't process again
if self.is_finalized {
return MetaPluginResponse {
metadata: Vec::new(),
is_finalized: true,
};
}
let mut metadata = Vec::new();
// Save the binary detection result when finalizing
let is_binary_result = is_binary(&self.buffer);
let value = if is_binary_result { "true".to_string() } else { "false".to_string() };
// Use process_metadata_outputs to handle output mapping
if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
"binary",
serde_yaml::Value::String(value),
self.base.outputs()
) {
metadata.push(meta_data);
}
// Mark as finalized
self.is_finalized = true;
MetaPluginResponse {
metadata,
is_finalized: true,
}
}
fn meta_type(&self) -> MetaPluginType {
MetaPluginType::Binary
}
fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
self.base.outputs()
}
fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
self.base.outputs_mut()
}
fn options(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
self.base.options()
}
fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
self.base.options_mut()
}
}

227
src/meta_plugin/command.rs
View File

@@ -1,227 +0,0 @@
use log::*;
use std::io::Write;
use std::process::{Command, Stdio, Child};
use which::which;
use crate::meta_plugin::{MetaPlugin, MetaPluginResponse, MetaPluginType};
pub struct MetaPluginExec {
pub program: String,
pub args: Vec<String>,
pub supported: bool,
pub split_whitespace: bool,
process: Option<Child>,
writer: Option<Box<dyn Write>>,
result: Option<String>,
outputs: std::collections::HashMap<String, serde_yaml::Value>,
options: std::collections::HashMap<String, serde_yaml::Value>,
}
// Manual Debug implementation because Box<dyn Write> doesn't implement Debug
impl std::fmt::Debug for MetaPluginExec {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MetaPluginExec")
.field("program", &self.program)
.field("args", &self.args)
.field("supported", &self.supported)
.field("split_whitespace", &self.split_whitespace)
.field("process", &self.process)
.field("writer", &self.writer.as_ref().map(|_| "Box<dyn Write>"))
.field("result", &self.result)
.field("outputs", &self.outputs)
.field("options", &self.options)
.finish()
}
}
impl MetaPluginExec {
pub fn new(
program: &str,
args: Vec<&str>,
meta_name: String,
split_whitespace: bool,
_options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
) -> MetaPluginExec {
let program_path = which(program);
let supported = program_path.is_ok();
// Start with default outputs
let mut final_outputs = std::collections::HashMap::new();
final_outputs.insert(meta_name.clone(), serde_yaml::Value::String(meta_name.clone()));
if let Some(outs) = outputs {
for (key, value) in outs {
final_outputs.insert(key, value);
}
}
// Start with default options
let mut final_options = std::collections::HashMap::new();
if let Some(opts) = _options {
for (key, value) in opts {
final_options.insert(key, value);
}
}
MetaPluginExec {
program: program_path.map_or_else(|_| program.to_string(), |p| p.to_string_lossy().to_string()),
args: args.iter().map(|s| s.to_string()).collect(),
supported,
split_whitespace,
process: None,
writer: None,
result: None,
outputs: final_outputs,
options: final_options,
}
}
}
impl MetaPlugin for MetaPluginExec {
fn is_supported(&self) -> bool {
self.supported
}
fn is_internal(&self) -> bool {
false
}
fn initialize(&mut self) -> MetaPluginResponse {
debug!("META: Initializing program plugin: {:?}", self);
let program = self.program.clone();
let args = self.args.clone();
debug!("META: Executing command: {:?} {:?}", program, args);
let mut process = match Command::new(program.clone())
.args(args.clone())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
{
Ok(process) => process,
Err(e) => {
debug!("META: Failed to spawn process: {}", e);
return MetaPluginResponse {
metadata: Vec::new(),
is_finalized: true,
};
}
};
let stdin = process.stdin.take().unwrap();
self.writer = Some(Box::new(stdin));
self.process = Some(process);
MetaPluginResponse {
metadata: Vec::new(),
is_finalized: false,
}
}
fn finalize(&mut self) -> MetaPluginResponse {
debug!("META: Finalizing program plugin");
let mut metadata = Vec::new();
if let Some(process) = self.process.take() {
// Close stdin to signal end of input
drop(self.writer.take());
// Wait for the process to complete
let output = match process.wait_with_output() {
Ok(output) => output,
Err(e) => {
debug!("META: Failed to get process output: {}", e);
return MetaPluginResponse {
metadata: Vec::new(),
is_finalized: true,
};
}
};
if output.status.success() {
// Process the output
let output_str = String::from_utf8_lossy(&output.stdout);
let result = if self.split_whitespace {
output_str.split_whitespace().next().unwrap_or("").to_string()
} else {
output_str.trim().to_string()
};
if !result.is_empty() {
debug!("META: Program output: {}", result);
self.result = Some(result.clone());
// Use process_metadata_outputs to handle output mapping
if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
&self.meta_type().to_string(),
serde_yaml::Value::String(result),
&self.outputs
) {
metadata.push(meta_data);
}
}
} else {
debug!("META: Program failed with status: {:?}", output.status);
let stderr = String::from_utf8_lossy(&output.stderr);
if !stderr.is_empty() {
debug!("META: Program stderr: {}", stderr);
}
}
}
MetaPluginResponse {
metadata,
is_finalized: true,
}
}
fn update(&mut self, data: &[u8]) -> MetaPluginResponse {
if let Some(ref mut writer) = self.writer {
if let Err(e) = writer.write_all(data) {
debug!("META: Failed to write to process stdin: {}", e);
}
}
MetaPluginResponse {
metadata: Vec::new(),
is_finalized: false,
}
}
fn meta_type(&self) -> MetaPluginType {
MetaPluginType::Exec
}
fn program_info(&self) -> Option<(&str, Vec<&str>)> {
if self.supported {
Some((&self.program, self.args.iter().map(|s| s.as_str()).collect()))
} else {
None
}
}
fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
&self.outputs
}
fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
&mut self.outputs
}
fn default_outputs(&self) -> Vec<String> {
vec![self.meta_type().to_string()]
}
fn options(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
&self.options
}
fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
&mut self.options
}
}

35
src/modes/diff.rs
View File

@@ -4,6 +4,7 @@ use std::io::Read;
use std::os::fd::FromRawFd;
use crate::config;
use crate::services::item_service::ItemService;
use log::debug;
fn validate_diff_args(cmd: &mut Command, ids: &Vec<i64>, tags: &Vec<String>) {
if !tags.is_empty() {
@@ -35,8 +36,8 @@ fn fetch_and_validate_items(
.get_item(conn, ids[1])
.with_context(|| format!("Unable to find second item (ID: {}) in database", ids[1]))?;
log::debug!("MAIN: Found item A {:?}", item_a.item);
log::debug!("MAIN: Found item B {:?}", item_b.item);
debug!("MAIN: Found item A {:?}", item_a.item);
debug!("MAIN: Found item B {:?}", item_b.item);
Ok((item_a, item_b))
}
@@ -94,7 +95,7 @@ fn spawn_diff_process(
fd_a_read: libc::c_int,
fd_b_read: libc::c_int,
) -> Result<std::process::Child, anyhow::Error> {
log::debug!("MAIN: Creating child process for diff");
debug!("MAIN: Creating child process for diff");
let mut diff_command = std::process::Command::new("diff");
diff_command
.arg("-u")
@@ -157,10 +158,10 @@ fn write_item_to_pipe(
let mut reader = engine.open(item_path)
.map_err(|e| anyhow::anyhow!("Failed to open item: {}", e))?;
log::debug!("THREAD: Sending item to diff");
debug!("THREAD: Sending item to diff");
std::io::copy(&mut reader, &mut buffered_pipe_writer)
.map_err(|e| anyhow::anyhow!("Failed to copy item to pipe: {}", e))?;
log::debug!("THREAD: Done sending item to diff");
debug!("THREAD: Done sending item to diff");
Ok(())
}
@@ -188,12 +189,12 @@ fn execute_diff_command(
.take()
.expect("BUG: Failed to capture diff stderr pipe");
log::debug!("MAIN: Creating threads for diff I/O");
debug!("MAIN: Creating threads for diff I/O");
// Thread to read diff's standard output
let stdout_reader_thread = std::thread::spawn(move || {
let mut output_buffer = Vec::new();
log::debug!("STDOUT_READER: Reading diff stdout");
debug!("STDOUT_READER: Reading diff stdout");
// child_stdout_pipe is a ChildStdout, which implements std::io::Read
child_stdout_pipe
.read_to_end(&mut output_buffer)
@@ -204,7 +205,7 @@ fn execute_diff_command(
// Thread to read diff's standard error
let stderr_reader_thread = std::thread::spawn(move || {
let mut error_buffer = Vec::new();
log::debug!("STDERR_READER: Reading diff stderr");
debug!("STDERR_READER: Reading diff stderr");
child_stderr_pipe
.read_to_end(&mut error_buffer)
.map_err(|e| anyhow::anyhow!("Failed to read diff stderr: {}", e))
@@ -238,7 +239,7 @@ fn handle_diff_output(
match diff_status.code() {
Some(0) => {
// Exit code 0: No differences
log::debug!("MAIN: Diff successful, no differences found.");
debug!("MAIN: Diff successful, no differences found.");
// Typically, diff -u doesn't print to stdout if no differences.
// But if it did, it would be shown here.
if !stdout_capture_result.is_empty() {
@@ -247,7 +248,7 @@ fn handle_diff_output(
}
Some(1) => {
// Exit code 1: Differences found
log::debug!("MAIN: Diff successful, differences found.");
debug!("MAIN: Diff successful, differences found.");
println!("{}", String::from_utf8_lossy(&stdout_capture_result));
}
Some(error_code) => {
@@ -335,10 +336,10 @@ pub fn mode_diff(
spawn_writer_thread(item_path_b.clone(), compression_type_b.clone(), fd_b_write);
// Wait for writer threads to complete (meaning all input has been sent to diff)
log::debug!("MAIN: Waiting on writer thread for item A");
debug!("MAIN: Waiting on writer thread for item A");
match writer_thread_a.join() {
Ok(Ok(())) => {
log::debug!("MAIN: Writer thread for item A completed successfully.");
debug!("MAIN: Writer thread for item A completed successfully.");
}
Ok(Err(e)) => {
return Err(anyhow::anyhow!("Writer thread for item A failed: {}", e));
@@ -352,10 +353,10 @@ pub fn mode_diff(
}
}
log::debug!("MAIN: Waiting on writer thread for item B");
debug!("MAIN: Waiting on writer thread for item B");
match writer_thread_b.join() {
Ok(Ok(())) => {
log::debug!("MAIN: Writer thread for item B completed successfully.");
debug!("MAIN: Writer thread for item B completed successfully.");
}
Ok(Err(e)) => {
return Err(anyhow::anyhow!("Writer thread for item B failed: {}", e));
@@ -369,18 +370,18 @@ pub fn mode_diff(
}
}
log::debug!("MAIN: Done waiting on input-writer threads.");
debug!("MAIN: Done waiting on input-writer threads.");
// Now that all input has been sent, the diff process will run to completion.
// We can read its output. This will block until the process is finished.
let (stdout_capture_result, stderr_capture_result) = execute_diff_command(&mut child_process)?;
// wait for the diff child process to terminate.
log::debug!("MAIN: Waiting for diff child process to finish...");
debug!("MAIN: Waiting for diff child process to finish...");
let diff_status = child_process
.wait()
.map_err(|e| anyhow::anyhow!("Failed to wait on diff command: {}", e))?;
log::debug!(
debug!(
"MAIN: Diff child process finished with status: {}",
diff_status
);

14
src/modes/status.rs
View File

@@ -2,6 +2,7 @@ use clap::*;
use is_terminal::IsTerminal;
use std::path::PathBuf;
use std::str::FromStr;
use log::debug;
use crate::modes::common::{get_format_box_chars_no_border_line_separator, OutputFormat};
use crate::config;
@@ -344,12 +345,12 @@ pub fn mode_status(
data_path: PathBuf,
db_path: PathBuf,
) -> Result<(), anyhow::Error> {
log::debug!("STATUS: Starting mode_status function");
debug!("STATUS: Starting mode_status function");
// Determine which meta plugins would be enabled for a save operation
log::debug!("STATUS: Getting meta plugin types from settings");
debug!("STATUS: Getting meta plugin types from settings");
let mut meta_plugin_types: Vec<MetaPluginType> = crate::modes::common::settings_meta_plugin_types(_cmd, settings);
log::debug!("STATUS: Got {} meta plugin types", meta_plugin_types.len());
debug!("STATUS: Got {} meta plugin types", meta_plugin_types.len());
// Always add the Digest plugin if not present
if !meta_plugin_types.contains(&MetaPluginType::Digest) {
@@ -364,9 +365,9 @@ pub fn mode_status(
};
let output_format = crate::modes::common::settings_output_format(settings);
log::debug!("STATUS: About to call generate_status_info");
debug!("STATUS: About to call generate_status_info");
let status_info = generate_status_info(data_path, db_path, &meta_plugin_types, enabled_compression_type);
log::debug!("STATUS: generate_status_info completed successfully");
debug!("STATUS: generate_status_info completed successfully");
match output_format {
OutputFormat::Table => {
@@ -377,11 +378,14 @@ pub fn mode_status(
println!("PATHS:");
build_path_table(&status_info.paths).printstd();
println!();
println!("COMPRESSION:");
build_compression_table(&status_info.compression).printstd();
println!();
println!("META PLUGINS AVAILABLE:");
build_meta_plugin_table(&status_info.meta_plugins).printstd();
println!();
// Print META PLUGINS CONFIGURED if they exist
if let Some(meta_plugins_table) = build_meta_plugins_configured_table(settings) {