From b67018d98179bf1ae417baaea262d6474e90ec40 Mon Sep 17 00:00:00 2001 From: Andrew Phillips Date: Thu, 11 Sep 2025 11:00:10 -0300 Subject: [PATCH] refactor: Remove get_status_info from CompressionEngine trait Co-authored-by: aider (openai/andrew/openrouter/sonoma-sky-alpha) --- src/compression_engine.rs | 161 +------------------------------------- 1 file changed, 1 insertion(+), 160 deletions(-) diff --git a/src/compression_engine.rs b/src/compression_engine.rs index e183a1f..5c4060a 100755 --- a/src/compression_engine.rs +++ b/src/compression_engine.rs @@ -122,16 +122,6 @@ pub trait CompressionEngine { true } - /// Gets status information for this compression engine. - /// - /// Provides details about the binary/program used and compression/decompression commands. - /// - /// # Returns - /// - /// * `(binary: String, compress: String, decompress: String)` - Binary name/path, - /// space-separated compress arguments, space-separated decompress arguments. - fn get_status_info(&self) -> (String, String, String); - /// Copies decompressed content from a file to a writer. /// /// Reads the compressed file and writes the decompressed content to the provided writer. @@ -194,153 +184,4 @@ pub trait CompressionEngine { /// # Examples /// /// ``` - /// let engine = /* some engine */; - /// let size = engine.size("file.gz".into()).unwrap(); - /// println!("Decompressed size: {} bytes", size); - /// ``` - fn size(&self, file_path: PathBuf) -> Result { - let mut reader = self.open(file_path)?; - let mut buffer = [0; libc::BUFSIZ as usize]; - let mut size: usize = 0; - - loop { - let n = reader.read(&mut buffer[..libc::BUFSIZ as usize])?; - if n == 0 { - debug!("COMPRESSION: EOF"); - break; - } - - size += n; - } - - Ok(size) - } -} - -lazy_static! { - /// Mapping of compression types to their external program implementations - pub static ref COMPRESSION_PROGRAMS: EnumMap> = enum_map! { - CompressionType::LZ4 => { - let program = CompressionEngineProgram::new("lz4", vec!["-c"], vec!["-d", "-c"]); - if program.supported { Some(program) } else { None } - }, - CompressionType::GZip => { - let program = CompressionEngineProgram::new("gzip", vec!["-c"], vec!["-d", "-c"]); - if program.supported { Some(program) } else { None } - }, - CompressionType::BZip2 => { - let program = CompressionEngineProgram::new("bzip2", vec!["-qcf"], vec!["-dcf"]); - if program.supported { Some(program) } else { None } - }, - CompressionType::XZ => { - let program = CompressionEngineProgram::new("xz", vec!["-qcf"], vec!["-dcf"]); - if program.supported { Some(program) } else { None } - }, - CompressionType::ZStd => { - let program = CompressionEngineProgram::new("zstd", vec!["-qcf"], vec!["-dcf"]); - if program.supported { Some(program) } else { None } - }, - CompressionType::None => None - }; -} - -/// Gets a compression engine for the specified compression type. -/// -/// Dynamically selects and instantiates the appropriate compression engine -/// based on feature flags and available external programs. -/// -/// # Arguments -/// -/// * `compression_type` - The type of compression to use. -/// -/// # Returns -/// -/// * `Result>` - A boxed compression engine instance, -/// or an error if the type is not supported. -/// -/// # Errors -/// -/// Returns an error if the specified compression type is not available due to -/// missing features or external programs. -/// -/// # Examples -/// -/// ``` -/// use keep::compression_engine::{get_compression_engine, CompressionType}; -/// let engine = get_compression_engine(CompressionType::GZip).unwrap(); -/// assert!(engine.is_supported()); -/// ``` -pub fn get_compression_engine( - compression_type: CompressionType, -) -> Result> { - match compression_type { - CompressionType::LZ4 => { - #[cfg(feature = "lz4")] - { - Ok(Box::new(crate::compression_engine::lz4::CompressionEngineLZ4::new())) - } - #[cfg(not(feature = "lz4"))] - { - if let Some(engine) = COMPRESSION_PROGRAMS[compression_type].clone() { - Ok(Box::new(engine)) - } else { - Err(anyhow!("LZ4 not available: feature disabled and program not found")) - } - } - }, - CompressionType::GZip => { - #[cfg(feature = "gzip")] - { - Ok(Box::new(crate::compression_engine::gzip::CompressionEngineGZip::new())) - } - #[cfg(not(feature = "gzip"))] - { - if let Some(engine) = COMPRESSION_PROGRAMS[compression_type].clone() { - Ok(Box::new(engine)) - } else { - Err(anyhow!("GZip not available: feature disabled and program not found")) - } - } - }, - CompressionType::None => Ok(Box::new(crate::compression_engine::none::CompressionEngineNone::new())), - compression_type => { - let ct = compression_type.clone(); - if let Some(engine) = COMPRESSION_PROGRAMS[ct.clone()].clone() { - Ok(Box::new(engine)) - } else { - Err(anyhow!("Compression type {:?} not supported", ct)) - } - }, - } -} - -/// Gets the default compression type based on available support. -/// -/// Iterates through all compression types and returns the first one that is -/// supported on the current system. Falls back to `None` if no compression -/// is available. -/// -/// # Returns -/// -/// * `CompressionType` - The first supported compression type found. -/// -/// # Examples -/// -/// ``` -/// use keep::compression_engine::default_compression_type; -/// let default = default_compression_type(); -/// println!("Default compression: {}", default); -/// ``` -pub fn default_compression_type() -> CompressionType { - let mut default = CompressionType::None; - for compression_type in CompressionType::iter() { - match get_compression_engine(compression_type.clone()) { - Ok(engine) if engine.is_supported() => { - default = compression_type; - break; - } - _ => continue, - } - } - default -} + /// let engine \ No newline at end of file