79 lines
2.4 KiB
Rust
79 lines
2.4 KiB
Rust
use std::io;
|
|
use std::io::Write;
|
|
use crate::Findings;
|
|
use crate::scanerror::ScanError;
|
|
use std::path::PathBuf;
|
|
use snailquote::escape;
|
|
|
|
type Entries = [Result<Findings, (ScanError, PathBuf)>];
|
|
|
|
pub trait Format {
|
|
fn new() -> Self;
|
|
fn rename<T: Write>(&self, f: &mut T, from: &str, to: &str) -> io::Result<()>;
|
|
fn no_known_extension<T: Write>(&self, f: &mut T, path: &str) -> io::Result<()>;
|
|
fn unreadable<T: Write>(&self, f: &mut T, path: &str) -> io::Result<()>;
|
|
fn unknown_type<T: Write>(&self, f: &mut T, path: &str) -> io::Result<()>;
|
|
|
|
fn write_all<T: Write>(&self, entries: &Entries, f: &mut T) -> io::Result<()> {
|
|
// TODO: clean this up - it's horrifying
|
|
for entry in entries {
|
|
match entry {
|
|
Ok(finding) => {
|
|
// the file was successfully scanned, and a mimetype was detected
|
|
if !finding.valid {
|
|
// the file's extension is wrong!
|
|
match finding.recommended_extension() {
|
|
Some(ext) => {
|
|
// there's a known extension for this mimetype!!
|
|
self.rename(
|
|
f,
|
|
&finding.file.to_string_lossy(),
|
|
&finding.file.with_extension(ext.as_str()).to_string_lossy()
|
|
)?
|
|
}
|
|
None => {
|
|
// unfortunately, there's no known extension for this mimetype :(
|
|
self.no_known_extension(f, &finding.file.to_string_lossy())?
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
Err(error) => {
|
|
// something went wrong 0uo
|
|
match error.0 {
|
|
// failed to read the file
|
|
ScanError::File => self.unreadable(f, &error.1.to_string_lossy())?,
|
|
// file was read successfully, but we couldn't determine a mimetype
|
|
ScanError::Mime => self.unknown_type(f, &error.1.to_string_lossy())?
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub struct Script {}
|
|
impl Format for Script {
|
|
fn new() -> Self {
|
|
return Script {}
|
|
}
|
|
|
|
fn rename<T: Write>(&self, f: &mut T, from: &str, to: &str) -> io::Result<()> {
|
|
// TODO: string escaping aaaaaaAAAAAAAAAA
|
|
writeln!(f, "mv -v -i -- {} {}", escape(from), escape(to))
|
|
}
|
|
|
|
fn no_known_extension<T: Write>(&self, f: &mut T, path: &str) -> io::Result<()> {
|
|
writeln!(f, "echo No known extension for {}!", escape(path))
|
|
}
|
|
|
|
fn unreadable<T: Write>(&self, f: &mut T, path: &str) -> io::Result<()> {
|
|
writeln!(f, "# Failed to read {}", escape(path))
|
|
}
|
|
|
|
fn unknown_type<T: Write>(&self, f: &mut T, path: &str) -> io::Result<()> {
|
|
writeln!(f, "# Failed to detect mime type for {}", escape(path))
|
|
}
|
|
} |