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

fix: resolve duplicate imports and add log::debug prefixes

Browse Source
This commit is contained in:
Andrew Phillips (aider)
2025-05-12 10:23:52 -03:00
parent 9418bf58ea
commit 74e4db0f65
2 changed files with 25 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/main.rs
View File

@@ -1,10 +1,4 @@
use nix::fcntl::FdFlag;
use nix::unistd::{close, pipe};
use nix::Error as NixError;
use std::io::Read;
use std::os::fd::FromRawFd;
use std::path::PathBuf;
use std::process::Stdio; // For Stdio::null, Stdio::piped
use anyhow::{anyhow, Context, Error, Result};
use clap::error::ErrorKind;

59
src/modes/diff.rs
View File

@@ -1,22 +1,13 @@
use crate::compression::CompressionType;
use crate::modes::common::format_size;
use crate::modes::common::get_format_box_chars_no_border_line_separator;
use crate::modes::common::ColumnType;
use crate::db::{get_item, get_item_last, get_item_matching};
use crate::modes::common::format_size;
use crate::modes::common::{format_size, ColumnType};
use std::path::PathBuf;
use std::str::FromStr;
use anyhow::{anyhow, Context, Error, Result};
use anyhow::{anyhow, Error, Result};
use clap::Command;
use is_terminal::IsTerminal;
use nix::fcntl::FdFlag;
use nix::unistd::{close, pipe};
use nix::Error as NixError;
use prettytable::format;
use prettytable::{Attr, Cell, Row, Table};
use std::collections::HashMap;
use std::fs;
use std::io::Read;
use std::os::fd::FromRawFd;
use std::process::Stdio;
@@ -31,7 +22,7 @@ pub fn mode_diff(
) -> Result<()> {
if !tags.is_empty() {
cmd.error(
clap::error::ErrorKind::InvalidValue,
ErrorKind::InvalidValue,
"Tags are not supported with --diff. Please provide exactly two IDs.",
)
.exit();
@@ -45,20 +36,20 @@ pub fn mode_diff(
}
// Fetch items, ensuring they exist.
let item_a = db::get_item(conn, ids[0])?
let item_a = crate::db::get_item(conn, ids[0])?
.ok_or_else(|| anyhow!("Unable to find first item (ID: {}) in database", ids[0]))?;
let item_b = db::get_item(conn, ids[1])?
let item_b = crate::db::get_item(conn, ids[1])?
.ok_or_else(|| anyhow!("Unable to find second item (ID: {}) in database", ids[1]))?;
debug!("MAIN: Found item A {:?}", item_a);
debug!("MAIN: Found item B {:?}", item_b);
log::debug!("MAIN: Found item A {:?}", item_a);
log::debug!("MAIN: Found item B {:?}", item_b);
let item_a_tags: Vec<String> = db::get_item_tags(conn, &item_a)?
let item_a_tags: Vec<String> = crate::db::get_item_tags(conn, &item_a)?
.into_iter()
.map(|x| x.name)
.collect();
let item_b_tags: Vec<String> = db::get_item_tags(conn, &item_b)?
let item_b_tags: Vec<String> = crate::db::get_item_tags(conn, &item_b)?
.into_iter()
.map(|x| x.name)
.collect();
@@ -94,7 +85,7 @@ pub fn mode_diff(
)
.map_err(|e| anyhow!("Failed to set FD_CLOEXEC on fd_b_write: {}", e))?;
debug!("MAIN: Creating child process for diff");
log::debug!("MAIN: Creating child process for diff");
let mut diff_command = std::process::Command::new("diff");
diff_command
.arg("-u")
@@ -132,7 +123,7 @@ pub fn mode_diff(
.take()
.expect("BUG: Failed to capture diff stderr pipe");
debug!("MAIN: Creating threads for diff I/O");
log::debug!("MAIN: Creating threads for diff I/O");
// Thread to write Item A data to diff
let writer_thread_a = {
@@ -145,7 +136,7 @@ pub fn mode_diff(
// This matches that style. For more robust error handling, return Result from thread.
use std::io::BufWriter;
let mut buffered_pipe_writer_a = BufWriter::new(pipe_writer_a_raw);
let engine_a = compression::get_engine(compression_type_a_clone)
let engine_a = crate::compression::get_engine(compression_type_a_clone)
.expect("Unable to get compression engine for Item A");
debug!("THREAD_A: Sending item A to diff");
engine_a
@@ -163,8 +154,8 @@ pub fn mode_diff(
let item_path_b_clone = item_path_b.clone();
let compression_type_b_clone = compression_type_b.clone();
std::thread::spawn(move || {
let mut buffered_pipe_writer_b = BufWriter::new(pipe_writer_b_raw);
let engine_b = compression::get_engine(compression_type_b_clone)
let mut buffered_pipe_writer_b = std::io::BufWriter::new(pipe_writer_b_raw);
let engine_b = crate::compression::get_engine(compression_type_b_clone)
.expect("Unable to get compression engine for Item B");
debug!("THREAD_B: Sending item B to diff");
engine_b
@@ -177,7 +168,7 @@ pub fn mode_diff(
// Thread to read diff's standard output
let stdout_reader_thread = std::thread::spawn(move || {
let mut output_buffer = Vec::new();
debug!("STDOUT_READER: Reading diff stdout");
log::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)
@@ -188,7 +179,7 @@ pub fn mode_diff(
// Thread to read diff's standard error
let stderr_reader_thread = std::thread::spawn(move || {
let mut error_buffer = Vec::new();
debug!("STDERR_READER: Reading diff stderr");
log::debug!("STDERR_READER: Reading diff stderr");
child_stderr_pipe
.read_to_end(&mut error_buffer)
.map_err(|e| anyhow!("Failed to read diff stderr: {}", e))
@@ -196,7 +187,7 @@ pub fn mode_diff(
});
// Wait for writer threads to complete (meaning all input has been sent to diff)
debug!("MAIN: Waiting on writer thread for item A");
log::debug!("MAIN: Waiting on writer thread for item A");
if let Err(panic_payload) = writer_thread_a.join() {
// Propagate panic from writer thread
return Err(anyhow!(
@@ -205,9 +196,9 @@ pub fn mode_diff(
panic_payload
));
}
debug!("MAIN: Writer thread for item A completed.");
log::debug!("MAIN: Writer thread for item A completed.");
debug!("MAIN: Waiting on writer thread for item B");
log::debug!("MAIN: Waiting on writer thread for item B");
if let Err(panic_payload) = writer_thread_b.join() {
return Err(anyhow!(
"Writer thread for item B (ID: {}) panicked: {:?}",
@@ -215,16 +206,16 @@ pub fn mode_diff(
panic_payload
));
}
debug!("MAIN: Writer thread for item B completed.");
debug!("MAIN: Done waiting on input-writer threads.");
log::debug!("MAIN: Writer thread for item B completed.");
log::debug!("MAIN: Done waiting on input-writer threads.");
// Now that all input has been sent and input pipes will be closed by threads exiting,
// wait for the diff child process to terminate.
debug!("MAIN: Waiting for diff child process to finish...");
log::debug!("MAIN: Waiting for diff child process to finish...");
let diff_status = child_process
.wait()
.map_err(|e| anyhow!("Failed to wait on diff command: {}", e))?;
debug!(
log::debug!(
"MAIN: Diff child process finished with status: {}",
diff_status
);
@@ -253,7 +244,7 @@ pub fn mode_diff(
match diff_status.code() {
Some(0) => {
// Exit code 0: No differences
debug!("MAIN: Diff successful, no differences found.");
log::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() {
@@ -262,7 +253,7 @@ pub fn mode_diff(
}
Some(1) => {
// Exit code 1: Differences found
debug!("MAIN: Diff successful, differences found.");
log::debug!("MAIN: Diff successful, differences found.");
println!("{}", String::from_utf8_lossy(&stdout_capture_result));
}
Some(error_code) => {