clippy

Author: bomgar

src/config/mod.rs

@@ -52,7 +52,7 @@ pub fn read_config() -> Result<Config, AppError> {
 					.ok_or(AppError::InternalError("Failed to get project name"))?;
 				project.project_config_path = PathBuf::from(project_file.path().parent().ok_or(AppError::InternalError("Expected file to have a parent"))?)
 					.strip_prefix(paths.projects.as_path())
-					.map_err(|e| AppError::RuntimeError(format!("Failed to strip prefix: {}", e)))?
+					.map_err(|e| AppError::RuntimeError(format!("Failed to strip prefix: {e}")))?
 					.to_string_lossy()
 					.to_string();
 				if projects.contains_key(&project.name) {
@@ -81,13 +81,12 @@ pub fn read_config() -> Result<Config, AppError> {
 					.ok_or(AppError::InternalError("Failed to get tag name"))?;
 				tag.tag_config_path = PathBuf::from(tag_file.path().parent().ok_or(AppError::InternalError("Expected file to have a parent"))?)
 					.strip_prefix(paths.tags.as_path())
-					.map_err(|e| AppError::RuntimeError(format!("Failed to strip prefix: {}", e)))?
+					.map_err(|e| AppError::RuntimeError(format!("Failed to strip prefix: {e}")))?
 					.to_string_lossy()
 					.to_string();
 				if tags.contains_key(&tag_name) {
 					eprintln!(
-						"Inconsistency found: tag {} defined more than once. Will use the project that is found last. Results might be inconsistent.",
-						tag_name
+						"Inconsistency found: tag {tag_name} defined more than once. Will use the project that is found last. Results might be inconsistent."
 					);
 				}
 				tags.insert(tag_name, tag);
@@ -121,7 +120,7 @@ pub fn write_settings(settings: &PersistedSettings) -> Result<(), AppError> {
 
 	let mut buffer = File::create(&paths.settings)?;
 	let serialized = toml::to_string_pretty(settings)?;
-	write!(buffer, "{}", serialized)?;
+	write!(buffer, "{serialized}")?;
 	write_example(&mut buffer, PersistedSettings::example())?;
 
 	Ok(())
@@ -142,8 +141,8 @@ pub fn write_tag(tag_name: &str, tag: &Tag) -> Result<(), AppError> {
 	let mut buffer = File::create(&tag_file_path)
 		.map_err(|e| AppError::RuntimeError(format!("Failed to create project config file '{}'. {}", tag_file_path.to_string_lossy(), e)))?;
 	let serialized = toml::to_string_pretty(&tag)?;
-	write!(buffer, "{}", CONF_MODE_HEADER)?;
-	write!(buffer, "{}", serialized)?;
+	write!(buffer, "{CONF_MODE_HEADER}")?;
+	write!(buffer, "{serialized}")?;
 	write_example(&mut buffer, Tag::example())?;
 	Ok(())
 }
@@ -156,7 +155,7 @@ pub fn delete_tag_config(tag_name: &str, tag: &Tag) -> Result<(), AppError> {
 	tag_file_path.push(PathBuf::from(&tag.tag_config_path));
 	tag_file_path.push(tag_name);
 
-	fs::remove_file(&tag_file_path).map_err(|e| AppError::RuntimeError(format!("Failed to delete tag config from '{:?}': {}", tag_file_path, e)))?;
+	fs::remove_file(&tag_file_path).map_err(|e| AppError::RuntimeError(format!("Failed to delete tag config from '{tag_file_path:?}': {e}")))?;
 	Ok(())
 }
 
@@ -168,7 +167,7 @@ pub fn delete_project_config(project: &Project) -> Result<(), AppError> {
 	project_file_path.push(PathBuf::from(&project.project_config_path));
 	project_file_path.push(&project.name);
 
-	fs::remove_file(project_file_path).map_err(|e| AppError::RuntimeError(format!("Failed to delete project config: {}", e)))?;
+	fs::remove_file(project_file_path).map_err(|e| AppError::RuntimeError(format!("Failed to delete project config: {e}")))?;
 	Ok(())
 }
 
@@ -180,7 +179,7 @@ where
 	writeln!(buffer, "\n# Example:")?;
 	for line in example_toml.split('\n') {
 		if line.trim() != "" {
-			writeln!(buffer, "# {}", line)?;
+			writeln!(buffer, "# {line}")?;
 		}
 	}
 	Ok(())
@@ -202,8 +201,8 @@ pub fn write_project(project: &Project) -> Result<(), AppError> {
 		.map_err(|e| AppError::RuntimeError(format!("Failed to create project config file '{}'. {}", project_file_path.to_string_lossy(), e)))?;
 	let serialized = toml::to_string_pretty(&project)?;
 
-	write!(buffer, "{}", CONF_MODE_HEADER)?;
-	write!(buffer, "{}", serialized)?;
+	write!(buffer, "{CONF_MODE_HEADER}")?;
+	write!(buffer, "{serialized}")?;
 	write_example(&mut buffer, Project::example())?;
 	Ok(())
 }

src/config/path.rs

@@ -12,7 +12,7 @@ pub struct FwPaths {
 
 impl FwPaths {
 	pub fn ensure_base_exists(&self) -> Result<(), AppError> {
-		std::fs::create_dir_all(&self.base).map_err(|e| AppError::RuntimeError(format!("Failed to create fw config base directory. {}", e)))?;
+		std::fs::create_dir_all(&self.base).map_err(|e| AppError::RuntimeError(format!("Failed to create fw config base directory. {e}")))?;
 		Ok(())
 	}
 }
@@ -46,11 +46,11 @@ pub fn fw_path() -> Result<FwPaths, AppError> {
 
 	let env: String = env::var_os("FW_ENV")
 		.map(|s| s.to_string_lossy().to_string())
-		.map(|s| format!("{}_", s))
+		.map(|s| format!("{s}_"))
 		.unwrap_or_default()
 		.replace('/', "");
 
-	settings.push(format!("{}settings.toml", env));
+	settings.push(format!("{env}settings.toml"));
 
 	let mut projects = base.clone();
 	projects.push("projects");

src/errors/mod.rs

@@ -40,17 +40,17 @@ impl AppError {
 impl fmt::Display for AppError {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		match *self {
-			AppError::Io(ref err) => write!(f, "Io error: {}", err),
-			AppError::UserError(ref str) => write!(f, "User error: {}", str),
-			AppError::RuntimeError(ref str) => write!(f, "Runtime error: {}", str),
-			AppError::BadJson(ref err) => write!(f, "JSON error: {}", err),
-			AppError::InternalError(str) => write!(f, "Internal error: {}", str),
-			AppError::GitError(ref err) => write!(f, "Git error: {}", err),
-			AppError::Regex(ref err) => write!(f, "Regex error: {}", err),
-			AppError::TomlSerError(ref err) => write!(f, "toml serialization error: {}", err),
-			AppError::TomlDeError(ref err) => write!(f, "toml read error: {}", err),
-			AppError::WalkdirError(ref err) => write!(f, "walkdir error: {}", err),
-			AppError::ReqwestError(ref err) => write!(f, "reqwest error: {}", err),
+			AppError::Io(ref err) => write!(f, "Io error: {err}"),
+			AppError::UserError(ref str) => write!(f, "User error: {str}"),
+			AppError::RuntimeError(ref str) => write!(f, "Runtime error: {str}"),
+			AppError::BadJson(ref err) => write!(f, "JSON error: {err}"),
+			AppError::InternalError(str) => write!(f, "Internal error: {str}"),
+			AppError::GitError(ref err) => write!(f, "Git error: {err}"),
+			AppError::Regex(ref err) => write!(f, "Regex error: {err}"),
+			AppError::TomlSerError(ref err) => write!(f, "toml serialization error: {err}"),
+			AppError::TomlDeError(ref err) => write!(f, "toml read error: {err}"),
+			AppError::WalkdirError(ref err) => write!(f, "walkdir error: {err}"),
+			AppError::ReqwestError(ref err) => write!(f, "reqwest error: {err}"),
 		}
 	}
 }
@@ -73,7 +73,7 @@ impl Error for AppError {
 
 impl From<core::num::ParseIntError> for AppError {
 	fn from(err: core::num::ParseIntError) -> AppError {
-		AppError::UserError(format!("Type error: {}", err))
+		AppError::UserError(format!("Type error: {err}"))
 	}
 }
 

src/git/mod.rs

@@ -14,9 +14,8 @@ use std::path::Path;
 pub fn repo_name_from_url(url: &str) -> Result<&str, AppError> {
 	let last_fragment = url.rsplit('/').next().ok_or_else(|| {
 		AppError::UserError(format!(
-			"Given URL {} does not have path fragments so cannot determine project name. Please give \
-       one.",
-			url
+			"Given URL {url} does not have path fragments so cannot determine project name. Please give \
+       one."
 		))
 	})?;
 
@@ -127,7 +126,7 @@ pub fn clone_project(config: &Config, project: &Project, path: &Path) -> Result<
 			let after_clone = config.resolve_after_clone(project);
 			if !after_clone.is_empty() {
 				spawn_maybe(&shell, &after_clone.join(" && "), path, &project.name, random_color())
-					.map_err(|error| AppError::UserError(format!("Post-clone hook failed (nonzero exit code). Cause: {:?}", error)))
+					.map_err(|error| AppError::UserError(format!("Post-clone hook failed (nonzero exit code). Cause: {error:?}")))
 			} else {
 				Ok(())
 			}

src/intellij/mod.rs

@@ -57,7 +57,7 @@ fn get_recent_projects_candidates() -> Result<Vec<PathBuf>, AppError> {
 }
 
 fn print_number_of_projects_warning(number_of_projects: usize) {
-	print!("WARNING: {} ", number_of_projects);
+	print!("WARNING: {number_of_projects} ");
 	print!("projects were added to the list. Intellij only lists 50 projects by default. You can change this in Intellij by going to ");
 	print!(r#"Settings -> Search for "recent" -> Pick the "Advanced Settings" -> adjust "Maximum number of recent projects"."#);
 	println!("A high number is recommended since it won't do any harm to the system.");

src/main.rs

@@ -15,8 +15,7 @@ fn _main() -> i32 {
 	let config = config::read_config();
 	if config.is_err() {
 		eprintln!(
-			"Could not read v2.0 config: {:?}. If you are running the setup right now this is expected.",
-			config
+			"Could not read v2.0 config: {config:?}. If you are running the setup right now this is expected."
 		);
 	};
 
@@ -144,7 +143,7 @@ fn _main() -> i32 {
 	match result {
 		Ok(()) => 0,
 		Err(error) => {
-			eprintln!("Error running command: error {}", error);
+			eprintln!("Error running command: error {error}");
 			1
 		}
 	}

src/project/mod.rs

@@ -18,13 +18,12 @@ pub fn add_entry(
 	trusted: bool,
 ) -> Result<(), AppError> {
 	let name = maybe_name
-		.ok_or_else(|| AppError::UserError(format!("No project name specified for {}", url)))
+		.ok_or_else(|| AppError::UserError(format!("No project name specified for {url}")))
 		.or_else(|_| repo_name_from_url(url).map(ToOwned::to_owned))?;
 	let config: Config = maybe_config?;
 	if config.projects.contains_key(&name) {
 		Err(AppError::UserError(format!(
-			"Project key {} already exists, not gonna overwrite it for you",
-			name
+			"Project key {name} already exists, not gonna overwrite it for you"
 		)))
 	} else {
 		let default_after_clone = config.settings.default_after_clone.clone();
@@ -56,7 +55,7 @@ pub fn remove_project(maybe_config: Result<Config, AppError>, project_name: &str
 	let config: Config = maybe_config?;
 
 	if !config.projects.contains_key(project_name) {
-		Err(AppError::UserError(format!("Project key {} does not exist in config", project_name)))
+		Err(AppError::UserError(format!("Project key {project_name} does not exist in config")))
 	} else if let Some(project) = config.projects.get(project_name).cloned() {
 		if purge_directory {
 			let path = config.actual_path_to_project(&project);
@@ -67,21 +66,20 @@ pub fn remove_project(maybe_config: Result<Config, AppError>, project_name: &str
 		}
 		config::delete_project_config(&project)
 	} else {
-		Err(AppError::UserError(format!("Unknown project {}", project_name)))
+		Err(AppError::UserError(format!("Unknown project {project_name}")))
 	}
 }
 
 pub fn add_remote(maybe_config: Result<Config, AppError>, name: &str, remote_name: String, git: String) -> Result<(), AppError> {
 	let config: Config = maybe_config?;
 	if !config.projects.contains_key(name) {
-		return Err(AppError::UserError(format!("Project key {} does not exists. Can not update.", name)));
+		return Err(AppError::UserError(format!("Project key {name} does not exists. Can not update.")));
 	}
 	let mut project_config: Project = config.projects.get(name).expect("Already checked in the if above").clone();
 	let mut additional_remotes = project_config.additional_remotes.unwrap_or_default();
 	if additional_remotes.iter().any(|r| r.name == remote_name) {
 		return Err(AppError::UserError(format!(
-			"Remote {} for project {} does already exist. Can not add.",
-			remote_name, name
+			"Remote {remote_name} for project {name} does already exist. Can not add."
 		)));
 	}
 	additional_remotes.push(Remote { name: remote_name, git });
@@ -94,7 +92,7 @@ pub fn add_remote(maybe_config: Result<Config, AppError>, name: &str, remote_nam
 pub fn remove_remote(maybe_config: Result<Config, AppError>, name: &str, remote_name: String) -> Result<(), AppError> {
 	let config: Config = maybe_config?;
 	if !config.projects.contains_key(name) {
-		return Err(AppError::UserError(format!("Project key {} does not exists. Can not update.", name)));
+		return Err(AppError::UserError(format!("Project key {name} does not exists. Can not update.")));
 	}
 	let mut project_config: Project = config.projects.get(name).expect("Already checked in the if above").clone();
 	let additional_remotes = project_config.additional_remotes.unwrap_or_default();
@@ -116,11 +114,10 @@ pub fn update_entry(
 	let config: Config = maybe_config?;
 	if name.starts_with("http") || name.starts_with("git@") {
 		Err(AppError::UserError(format!(
-			"{} looks like a repo URL and not like a project name, please fix",
-			name
+			"{name} looks like a repo URL and not like a project name, please fix"
 		)))
 	} else if !config.projects.contains_key(name) {
-		Err(AppError::UserError(format!("Project key {} does not exists. Can not update.", name)))
+		Err(AppError::UserError(format!("Project key {name} does not exists. Can not update.")))
 	} else {
 		let old_project_config: Project = config.projects.get(name).expect("Already checked in the if above").clone();
 		config::write_project(&Project {
@@ -143,7 +140,7 @@ pub fn ls(maybe_config: Result<Config, AppError>, tags: &BTreeSet<String>) -> Re
 	let config = maybe_config?;
 	for (name, project) in config.projects {
 		if tags.is_empty() || project.tags.unwrap_or_default().intersection(tags).count() > 0 {
-			println!("{}", name)
+			println!("{name}")
 		}
 	}
 	Ok(())
@@ -154,12 +151,12 @@ pub fn print_path(maybe_config: Result<Config, AppError>, name: &str) -> Result<
 	let project = config
 		.projects
 		.get(name)
-		.ok_or_else(|| AppError::UserError(format!("project {} not found", name)))?;
+		.ok_or_else(|| AppError::UserError(format!("project {name} not found")))?;
 	let canonical_project_path = config.actual_path_to_project(project);
 	let path = canonical_project_path
 		.to_str()
 		.ok_or(AppError::InternalError("project path is not valid unicode"))?;
-	println!("{}", path);
+	println!("{path}");
 	Ok(())
 }
 
@@ -168,7 +165,7 @@ pub fn inspect(name: &str, maybe_config: Result<Config, AppError>, json: bool) -
 	let project = config
 		.projects
 		.get(name)
-		.ok_or_else(|| AppError::UserError(format!("project {} not found", name)))?;
+		.ok_or_else(|| AppError::UserError(format!("project {name} not found")))?;
 	if json {
 		println!("{}", serde_json::to_string(project)?);
 		return Ok(());
@@ -208,7 +205,7 @@ pub(crate) fn move_project(maybe_config: Result<Config, AppError>, name: &str, d
 	let project = config
 		.projects
 		.get(name)
-		.ok_or_else(|| AppError::UserError(format!("project {} not found", name)))?;
+		.ok_or_else(|| AppError::UserError(format!("project {name} not found")))?;
 	let canonical_project_path = config.actual_path_to_project(project);
 
 	let mut path = path::absolute(destination)?;

src/projectile/mod.rs

@@ -27,7 +27,7 @@ where
 	buffer.write_all(b"(")?;
 	for path in paths {
 		let path = replace_path_with_tilde(&path, home_dir.to_path_buf()).unwrap_or(path);
-		buffer.write_all(format!("\"{}/\"", path).as_bytes())?;
+		buffer.write_all(format!("\"{path}/\"").as_bytes())?;
 		buffer.write_all(b" ")?;
 	}
 	buffer.write_all(b")")?;

src/setup/mod.rs

@@ -48,15 +48,15 @@ pub fn setup(workspace_dir: &str) -> Result<(), AppError> {
 	let maybe_path = if path.exists() {
 		Ok(path)
 	} else {
-		Err(AppError::UserError(format!("Given workspace path {} does not exist", workspace_dir)))
+		Err(AppError::UserError(format!("Given workspace path {workspace_dir} does not exist")))
 	};
 
 	maybe_path
 		.and_then(|path| {
 			if path.is_absolute() {
 				Ok(path)
 			} else {
-				Err(AppError::UserError(format!("Workspace path {} needs to be absolute", workspace_dir)))
+				Err(AppError::UserError(format!("Workspace path {workspace_dir} needs to be absolute")))
 			}
 		})
 		.and_then(determine_projects)
@@ -80,7 +80,7 @@ fn determine_projects(path: PathBuf) -> Result<BTreeMap<String, Project>, AppErr
 						Ok(project) => {
 							projects.insert(project.name.clone(), project);
 						}
-						Err(e) => eprintln!("Error while importing folder. Skipping it. {}", e),
+						Err(e) => eprintln!("Error while importing folder. Skipping it. {e}"),
 					}
 				}
 				Err(_) => eprintln!("Failed to parse directory name as unicode. Skipping it."),
@@ -98,8 +98,7 @@ pub fn org_import(maybe_config: Result<Config, AppError>, org_name: &str, includ
 		.or_else(|| current_config.settings.github_token.clone())
 		.ok_or_else(|| {
 			AppError::UserError(format!(
-				"Can't call GitHub API for org {} because no github oauth token (settings.github_token) specified in the configuration.",
-				org_name
+				"Can't call GitHub API for org {org_name} because no github oauth token (settings.github_token) specified in the configuration."
 			))
 		})?;
 	let mut api = github::github_api(&token)?;
@@ -112,7 +111,7 @@ pub fn org_import(maybe_config: Result<Config, AppError>, org_name: &str, includ
 	for name in org_repository_names {
 		let p = Project {
 			name: name.clone(),
-			git: format!("git@github.com:{}/{}.git", org_name, name),
+			git: format!("git@github.com:{org_name}/{name}.git"),
 			after_clone: after_clone.clone(),
 			after_workon: after_workon.clone(),
 			override_path: None,