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

refactor: Remove get_status_info from CompressionEngine trait

Browse Source 
Co-authored-by: aider (openai/andrew/openrouter/sonoma-sky-alpha) <aider@aider.chat>
This commit is contained in:
Andrew Phillips
2025-09-11 11:00:10 -03:00
parent f2d340e778
commit b67018d981
1 changed files with 1 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

161
src/compression_engine.rs
View File

@@ -122,16 +122,6 @@ pub trait CompressionEngine {
true 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. /// Copies decompressed content from a file to a writer.
/// ///
/// Reads the compressed file and writes the decompressed content to the provided writer. /// Reads the compressed file and writes the decompressed content to the provided writer.
@@ -194,153 +184,4 @@ pub trait CompressionEngine {
/// # Examples /// # Examples
/// ///
/// ``` /// ```
/// let engine = /* some engine */; /// let engine
/// let size = engine.size("file.gz".into()).unwrap();
/// println!("Decompressed size: {} bytes", size);
/// ```
fn size(&self, file_path: PathBuf) -> Result<usize> {
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<CompressionType, Option<CompressionEngineProgram>> = 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<Box<dyn CompressionEngine>>` - 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<Box<dyn CompressionEngine>> {
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
}