Cargo.toml

@@ -14,9 +14,6 @@ exclude = [".idea/", "Cross.toml", "*.sh", "*.py", ".drone.yml"]
 #resolver = "2"
 #license-file = "LICENSE"
 
-[badges]
-maintenance = { status = "experimental" }
-
 [features]
 default = ["multi-threaded"]
 multi-threaded = ["rayon"]

src/formats.rs

@@ -7,14 +7,14 @@ use std::path::PathBuf;
 
 use snailquote::escape;
 
-use crate::scan_error::ScanError;
+use crate::scanerror::ScanError;
 use crate::{Findings, BACKEND};
 
 /// The current version of fif, as defined in Cargo.toml.
 const VERSION: Option<&'static str> = option_env!("CARGO_PKG_VERSION");
 
 #[doc(hidden)]
-type Entries = [Result<Findings, ScanError>];
+type Entries = [Result<Findings, (ScanError, PathBuf)>];
 
 enum Writable<'a> {
 	String(&'a str),
@@ -86,11 +86,11 @@ pub trait Format {
 
 				Err(error) => {
 					// something went wrong 0uo
-					match error {
+					match error.0 {
 						// failed to read the file
-						ScanError::File(path) => self.unreadable(f, path)?,
+						ScanError::File => self.unreadable(f, &error.1)?,
 						// file was read successfully, but we couldn't determine a mimetype
-						ScanError::Mime(path) => self.unknown_type(f, path)?,
+						ScanError::Mime => self.unknown_type(f, &error.1)?,
 					}
 				}
 			}

src/inspectors.rs

@@ -10,7 +10,7 @@ use cached::cached;
 use mime_guess::Mime;
 use smartstring::alias::String;
 
-use crate::mime_db::MimeDb;
+use crate::mimedb::MimeDb;
 
 /// The number of bytes to read initially.
 ///

src/main.rs

@@ -28,32 +28,32 @@ use walkdir::{DirEntry, WalkDir};
 
 use crate::findings::Findings;
 use crate::formats::{Format, Script};
-use crate::mime_db::MimeDb;
+use crate::mimedb::MimeDb;
 use crate::parameters::OutputFormat;
-use crate::scan_error::ScanError;
+use crate::scanerror::ScanError;
 use env_logger::Env;
 use std::process::exit;
 
-mod extension_set;
+mod extensionset;
 mod findings;
 mod formats;
 mod inspectors;
-mod mime_db;
+mod mimedb;
 mod parameters;
-mod scan_error;
+mod scanerror;
 
 #[cfg(test)]
 mod tests;
 
 cfg_if! {
 	if #[cfg(any(all(not(unix), not(feature = "xdg-mime-backend")), all(unix, feature = "infer-backend")))] {
-		/// A [OnceCell] holding an instance of [mime_db::MimeDb].
+		/// A [OnceCell] holding an instance of [mimedb::MimeDb].
-		static MIMEDB: OnceCell<mime_db::InferDb> = OnceCell::new();
+		static MIMEDB: OnceCell<mimedb::InferDb> = OnceCell::new();
 		/// The backend being used; either "Infer" or "XDG-Mime".
 		const BACKEND: &str = "Infer";
 	} else {
-		/// A [OnceCell] holding an instance of [mime_db::MimeDb].
+		/// A [OnceCell] holding an instance of [mimedb::MimeDb].
-		static MIMEDB: OnceCell<mime_db::XdgDb> = OnceCell::new();
+		static MIMEDB: OnceCell<mimedb::XdgDb> = OnceCell::new();
 		/// The backend being used; either "Infer" or "XDG-Mime".
 		const BACKEND: &str = "XDG-Mime";
 	}
@@ -116,7 +116,7 @@ fn main() {
 					r.recommended_extension().unwrap_or_else(|| "???".into())
 				)
 			}
-			Err(f) => warn!("Error 0uo - {}", f),
+			Err(f) => warn!("{:#?}: Error 0uo - {}", f.1, f.0),
 		}
 	}
 
@@ -191,26 +191,26 @@ fn extension_from_path(path: &Path) -> Option<String> {
 		map(|e| String::from(e.to_string_lossy())) // Convert from OsStr to String
 }
 
-/// Inspects the given entry, returning a [Findings] on success and a [ScanError] on failure.
+/// Inspects the given entry, returning a [Findings] on success and a tuple of [ScanError] and [PathBuf] on failure.
 ///
 /// In the event of an IO error, the returned ScanError will be of type [ScanError::File]. Otherwise, a
 /// [ScanError::Mime] will be returned, meaning that the file was scanned successfully, but a mimetype could not be
 /// determined.
-fn scan_file(entry: &DirEntry) -> Result<Findings, ScanError> {
+fn scan_file(entry: &DirEntry) -> Result<Findings, (ScanError, PathBuf)> {
 	// try to determine mimetype for this entry
 	let result = inspectors::mime_type(MIMEDB.get().unwrap(), entry.path());
 
 	if result.is_err() {
 		// an error occurred while trying to read the file
 		// error!("{}: {}", entry.path().to_string_lossy(), error);
-		return Err(ScanError::File(entry.path().to_path_buf()));
+		return Err((ScanError::File, entry.path().to_path_buf()));
 	}
 
 	let result = result.unwrap();
 	if result.is_none() {
 		// the file was read successfully, but we were unable to determine its mimetype
 		// warn!("Couldn't determine mimetype for {}", entry.path().to_string_lossy());
-		return Err(ScanError::Mime(entry.path().to_path_buf()));
+		return Err((ScanError::Mime, entry.path().to_path_buf()));
 	}
 
 	let result = result.unwrap();
@@ -235,7 +235,7 @@ fn scan_file(entry: &DirEntry) -> Result<Findings, ScanError> {
 }
 
 /// Takes a slice of [DirEntry]s and calls [scan_file] on each one, returning the results in a vector.
-fn scan_from_walkdir(entries: &[DirEntry]) -> Vec<Result<Findings, ScanError>> {
+fn scan_from_walkdir(entries: &[DirEntry]) -> Vec<Result<Findings, (ScanError, PathBuf)>> {
 	cfg_if! {
 		if #[cfg(feature = "multi-threaded")] {
 			// rather than using a standard par_iter, split the entries into chunks of 32 first.
@@ -301,12 +301,12 @@ fn init_db() {
 	cfg_if! {
 		if #[cfg(any(all(not(unix), not(feature = "xdg-mime-backend")), all(unix, feature = "infer-backend")))] {
 			MIMEDB
-				.set(mime_db::InferDb::init())
+				.set(mimedb::InferDb::init())
 				.or(Err("Failed to initialise Infer backend!"))
 				.unwrap();
 		} else {
 			MIMEDB
-				.set(mime_db::XdgDb::init())
+				.set(mimedb::XdgDb::init())
 				.or(Err("Failed to initialise XDG Mime backend!"))
 				.unwrap();
 		}

src/parameters.rs

@@ -2,32 +2,20 @@
 
 use std::path::PathBuf;
 
-use crate::extension_set::ExtensionSet;
+use crate::extensionset::ExtensionSet;
-use clap::{Clap, AppSettings};
+use clap::{Clap};
 use smartstring::{LazyCompact, SmartString};
 
 #[derive(Clap, PartialEq, Debug)]
 pub enum OutputFormat {
-	/// A Bourne shell compatible script.
 	Script,
-	/// Plain text.
 	Text,
 }
 
 // TODO: convert this to macro style?: https://docs.rs/clap/3.0.0-beta.2/clap/index.html#using-macros
 
 #[derive(Clap, Debug)]
-#[clap(
+#[clap(version = option_env!("CARGO_PKG_VERSION").unwrap_or("???"))]
-	version = option_env!("CARGO_PKG_VERSION").unwrap_or("???"),
-	author = option_env!("CARGO_PKG_AUTHORS").unwrap_or("Lynnesbian"),
-	about = option_env!("CARGO_PKG_DESCRIPTION").unwrap_or("File Info Fixer"),
-	before_help = "Copyright © 2021 Lynnesbian under the GPL3 (or later) License.",
-	before_long_help = "Copyright © 2021 Lynnesbian\n\
-	This program is free software: you can redistribute it and/or modify \
-	it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 \
-	of the License, or (at your option) any later version.",
-	setting(AppSettings::ColoredHelp)
-)]
 pub struct Parameters {
 	/// Only examine files with these extensions (Comma-separated list)
 	#[clap(
@@ -39,7 +27,7 @@ pub struct Parameters {
 	)]
 	pub exts: Option<Vec<SmartString<LazyCompact>>>,
 
-	/// Use a preset list of extensions as the search filter
+	/// write good docs 0uo
 	#[clap(short = 'E', long, arg_enum, required_unless_present = "exts")]
 	pub ext_set: Option<ExtensionSet>,
 
@@ -47,7 +35,7 @@ pub struct Parameters {
 	#[clap(short, long)]
 	pub scan_hidden: bool,
 
-	/// Output format to use
+	/// Output format to use. See "--help formats" for more information.
 	#[clap(short, long, default_value = "script", arg_enum)]
 	pub output_format: OutputFormat,
 

src/scanerror.rs

@@ -1,25 +1,21 @@
 use std::fmt::{Display, Formatter, Result};
-use std::path::PathBuf;
 
 #[derive(Debug)]
 pub enum ScanError {
 	/// Something went wrong while trying to read the given file.
-	File(PathBuf),
+	File,
 	/// Failed to determine the mimetype of the given file.
-	Mime(PathBuf),
+	Mime,
 }
 
 impl Display for ScanError {
 	fn fmt(&self, f: &mut Formatter<'_>) -> Result {
 		write!(
 			f,
-			"Couldn't {} file: {}",
+			"{}",
 			match self {
-				Self::File(_) => "read",
+				Self::File => "Couldn't read file",
-				Self::Mime(_) => "determine mime type of",
+				Self::Mime => "Couldn't determine mime type",
-			},
-			match self {
-				Self::File(f) | Self::Mime(f) => f.to_string_lossy(),
 			}
 		)
 	}

src/tests/mod.rs

@@ -1,5 +1,5 @@
 use crate::inspectors::mime_extension_lookup;
-use crate::mime_db::*;
+use crate::mimedb::*;
 use crate::{extension_from_path, init_db, scan_directory, scan_from_walkdir};
 
 use crate::parameters::Parameters;