remove warnings

src/config/mod.rs

@@ -31,7 +31,6 @@ pub fn read_config() -> Result<Config, AppError> {
 
   let settings: PersistedSettings = toml::from_str(&settings_raw)?;
 
-
   let mut projects: BTreeMap<String, Project> = BTreeMap::new();
   if paths.projects.exists() {
     for maybe_project_file in WalkDir::new(&paths.projects).follow_links(true) {
@@ -58,7 +57,8 @@ pub fn read_config() -> Result<Config, AppError> {
           .to_string();
         if projects.contains_key(&project.name) {
           eprintln!(
-            "Inconsistency found: project {} defined more than once. Will use the project that is found last. Results might be inconsistent.", project.name
+            "Inconsistency found: project {} defined more than once. Will use the project that is found last. Results might be inconsistent.",
+            project.name
           );
         }
         projects.insert(project.name.clone(), project);
@@ -86,7 +86,8 @@ pub fn read_config() -> Result<Config, AppError> {
           .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 {} defined more than once. Will use the project that is found last. Results might be inconsistent.",
+            tag_name
           );
         }
         tags.insert(tag_name, tag);
@@ -124,7 +125,6 @@ pub fn write_settings(settings: &PersistedSettings) -> Result<(), AppError> {
   write!(buffer, "{}", serialized)?;
   write_example(&mut buffer, PersistedSettings::example())?;
 
-
   Ok(())
 }
 
@@ -219,12 +219,12 @@ impl Config {
     expand_path(path)
   }
 
-  fn resolve_workspace(&self,  project: &Project) -> String {
+  fn resolve_workspace(&self, project: &Project) -> String {
     let mut x = self.resolve_from_tags(|tag| tag.workspace.clone(), project.tags.clone());
     let workspace = x.pop().unwrap_or_else(|| self.settings.workspace.clone());
     workspace
   }
-  pub fn resolve_after_clone(&self,  project: &Project) -> Vec<String> {
+  pub fn resolve_after_clone(&self, project: &Project) -> Vec<String> {
     let mut commands: Vec<String> = vec![];
     commands.extend_from_slice(&self.resolve_after_clone_from_tags(project.tags.clone()));
     let commands_from_project: Vec<String> = project.after_clone.clone().into_iter().collect();
@@ -246,7 +246,7 @@ impl Config {
     self.resolve_from_tags(|t| t.clone().after_clone, maybe_tags)
   }
 
-  fn tag_priority_or_fallback(&self, name: &str, tag: &Tag) -> u8 {
+  fn tag_priority_or_fallback(&self, tag: &Tag) -> u8 {
     match tag.priority {
       None => 50,
       Some(p) => p,
@@ -265,7 +265,7 @@ impl Config {
             eprintln!("Ignoring tag since it was not found in the config. missing_tag {}", t.clone());
             None
           }
-          Some(actual_tag) => resolver(actual_tag).map(|val| (val, self.tag_priority_or_fallback(t, actual_tag))),
+          Some(actual_tag) => resolver(actual_tag).map(|val| (val, self.tag_priority_or_fallback(actual_tag))),
         })
         .collect();
       resolved_with_priority.sort_by_key(|resolved_and_priority| resolved_and_priority.1);
@@ -284,61 +284,61 @@ mod tests {
   #[test]
   fn test_workon_from_tags() {
     let config = a_config();
-    let resolved = config.resolve_after_workon( config.projects.get("test1").unwrap());
+    let resolved = config.resolve_after_workon(config.projects.get("test1").unwrap());
     assert_eq!(resolved, vec!["workon1".to_string(), "workon2".to_string()]);
   }
   #[test]
   fn test_workon_from_tags_prioritized() {
     let config = a_config();
-    let resolved = config.resolve_after_workon( config.projects.get("test5").unwrap());
+    let resolved = config.resolve_after_workon(config.projects.get("test5").unwrap());
     assert_eq!(resolved, vec!["workon4".to_string(), "workon3".to_string()]);
   }
   #[test]
   fn test_after_clone_from_tags() {
     let config = a_config();
-    let resolved = config.resolve_after_clone( config.projects.get("test1").unwrap());
+    let resolved = config.resolve_after_clone(config.projects.get("test1").unwrap());
     assert_eq!(resolved, vec!["clone1".to_string(), "clone2".to_string()]);
   }
   #[test]
   fn test_after_clone_from_tags_prioritized() {
     let config = a_config();
-    let resolved = config.resolve_after_clone( config.projects.get("test5").unwrap());
+    let resolved = config.resolve_after_clone(config.projects.get("test5").unwrap());
     assert_eq!(resolved, vec!["clone4".to_string(), "clone3".to_string()]);
   }
   #[test]
   fn test_workon_from_tags_missing_one_tag_graceful() {
     let config = a_config();
-    let resolved = config.resolve_after_workon( config.projects.get("test2").unwrap());
+    let resolved = config.resolve_after_workon(config.projects.get("test2").unwrap());
     assert_eq!(resolved, vec!["workon1".to_owned()]);
   }
   #[test]
   fn test_workon_from_tags_missing_all_tags_graceful() {
     let config = a_config();
-    let resolved = config.resolve_after_workon( config.projects.get("test4").unwrap());
+    let resolved = config.resolve_after_workon(config.projects.get("test4").unwrap());
     assert_eq!(resolved, Vec::<String>::new());
   }
   #[test]
   fn test_after_clone_from_tags_missing_all_tags_graceful() {
     let config = a_config();
-    let resolved = config.resolve_after_clone( config.projects.get("test4").unwrap());
+    let resolved = config.resolve_after_clone(config.projects.get("test4").unwrap());
     assert_eq!(resolved, Vec::<String>::new());
   }
   #[test]
   fn test_after_clone_from_tags_missing_one_tag_graceful() {
     let config = a_config();
-    let resolved = config.resolve_after_clone( config.projects.get("test2").unwrap());
+    let resolved = config.resolve_after_clone(config.projects.get("test2").unwrap());
     assert_eq!(resolved, vec!["clone1".to_owned()]);
   }
   #[test]
   fn test_workon_override_from_project() {
     let config = a_config();
-    let resolved = config.resolve_after_workon( config.projects.get("test3").unwrap());
+    let resolved = config.resolve_after_workon(config.projects.get("test3").unwrap());
     assert_eq!(resolved, vec!["workon1".to_string(), "workon override in project".to_owned()]);
   }
   #[test]
   fn test_after_clone_override_from_project() {
     let config = a_config();
-    let resolved = config.resolve_after_clone( config.projects.get("test3").unwrap());
+    let resolved = config.resolve_after_clone(config.projects.get("test3").unwrap());
     assert_eq!(resolved, vec!["clone1".to_string(), "clone override in project".to_owned()]);
   }
 
@@ -458,5 +458,4 @@ mod tests {
     };
     Config { projects, settings }
   }
-
 }

src/errors/mod.rs

@@ -1,7 +1,6 @@
 use std::error::Error;
 use std::fmt;
 use std::io;
-use std::time::SystemTimeError;
 
 #[derive(Debug)]
 pub enum AppError {
@@ -10,7 +9,6 @@ pub enum AppError {
   RuntimeError(String),
   BadJson(serde_json::Error),
   InternalError(&'static str),
-  ClockError(SystemTimeError),
   GitError(git2::Error),
   Regex(regex::Error),
   TomlSerError(toml::ser::Error),
@@ -47,7 +45,6 @@ impl fmt::Display for AppError {
       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::ClockError(ref err) => write!(f, "System clock error: {}", err),
       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),
@@ -66,7 +63,6 @@ impl Error for AppError {
       AppError::UserError(ref str) | AppError::RuntimeError(ref str) => str.as_ref(),
       AppError::BadJson(ref err) => err.description(),
       AppError::InternalError(str) => str,
-      AppError::ClockError(ref err) => err.description(),
       AppError::GitError(ref err) => err.description(),
       AppError::Regex(ref err) => err.description(),
       AppError::TomlSerError(ref err) => err.description(),
@@ -81,7 +77,6 @@ impl Error for AppError {
       AppError::Io(ref err) => Some(err),
       AppError::UserError(_) | AppError::RuntimeError(_) | AppError::InternalError(_) => None,
       AppError::BadJson(ref err) => Some(err),
-      AppError::ClockError(ref err) => Some(err),
       AppError::GitError(ref err) => Some(err),
       AppError::Regex(ref err) => Some(err),
       AppError::TomlSerError(ref err) => Some(err),

src/git/mod.rs

@@ -52,28 +52,22 @@ fn builder() -> RepoBuilder<'static> {
   repo_builder
 }
 
-fn update_remote(project: &Project, remote: &mut Remote<'_>) -> Result<(), AppError> {
+fn update_remote(remote: &mut Remote<'_>) -> Result<(), AppError> {
   let remote_callbacks = agent_callbacks();
   let mut proxy_options = ProxyOptions::new();
   proxy_options.auto();
   remote
     .connect_auth(Direction::Fetch, Some(remote_callbacks), Some(proxy_options))
-    .map_err(|error| {
-      AppError::GitError(error)
-    })?;
+    .map_err(|error| AppError::GitError(error))?;
   let mut options = agent_fetch_options();
-  remote.download::<String>(&[], Some(&mut options)).map_err(|error| {
-    AppError::GitError(error)
-  })?;
+  remote.download::<String>(&[], Some(&mut options)).map_err(|error| AppError::GitError(error))?;
   remote.disconnect()?;
   remote.update_tips(None, true, AutotagOption::Unspecified, None)?;
   Ok(())
 }
 
 pub fn update_project_remotes(project: &Project, path: &Path, ff_merge: bool) -> Result<(), AppError> {
-  let local: Repository = Repository::open(path).map_err(|error| {
-    AppError::GitError(error)
-  })?;
+  let local: Repository = Repository::open(path).map_err(|error| AppError::GitError(error))?;
   for desired_remote in project.additional_remotes.clone().unwrap_or_default().into_iter().chain(
     vec![crate::config::project::Remote {
       name: "origin".to_string(),
@@ -93,12 +87,12 @@ pub fn update_project_remotes(project: &Project, path: &Path, ff_merge: bool) ->
       }
     };
 
-    update_remote(project, &mut remote)?;
+    update_remote(&mut remote)?;
   }
 
   if ff_merge {
-    if let Err(error) = fast_forward_merge(&local) {
-      // does not matter
+    if let Err(_) = fast_forward_merge(&local) {
+      // does not matter. fast forward not possible
     }
   }
 
@@ -112,7 +106,6 @@ fn fast_forward_merge(local: &Repository) -> Result<(), AppError> {
     let upstream = branch.upstream()?;
     let upstream_commit = local.reference_to_annotated_commit(upstream.get())?;
 
-
     let (analysis_result, _) = local.merge_analysis(&[&upstream_commit])?;
     if MergeAnalysis::is_fast_forward(&analysis_result) {
       let target_id = upstream_commit.id();
@@ -129,9 +122,7 @@ pub fn clone_project(config: &Config, project: &Project, path: &Path) -> Result<
   repo_builder
     .bare(project.bare.unwrap_or_default())
     .clone(project.git.as_str(), path)
-    .map_err(|error| {
-      AppError::GitError(error)
-    })
+    .map_err(|error| AppError::GitError(error))
     .and_then(|repo| init_additional_remotes(project, repo))
     .and_then(|_| {
       let after_clone = config.resolve_after_clone(project);
@@ -148,7 +139,7 @@ fn init_additional_remotes(project: &Project, repository: Repository) -> Result<
   if let Some(additional_remotes) = &project.additional_remotes {
     for remote in additional_remotes {
       let mut git_remote = repository.remote(&remote.name, &remote.git)?;
-      update_remote(project, &mut git_remote)?;
+      update_remote(&mut git_remote)?;
     }
   }
   Ok(())

src/main.rs

@@ -1,7 +1,6 @@
 use crate::errors::AppError;
 use setup::ProjectState;
 use std::collections::BTreeSet;
-use std::time::SystemTime;
 
 fn main() {
   openssl_probe::init_ssl_cert_env_vars();
@@ -12,19 +11,18 @@ fn main() {
 fn _main() -> i32 {
   let matches = crate::app::app().get_matches();
 
-
   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: {:?}. If you are running the setup right now this is expected.",
+      config
     );
   };
 
   let subcommand_name = matches.subcommand_name().expect("subcommand required by clap.rs").to_owned();
   let subcommand_matches = matches.subcommand_matches(&subcommand_name).expect("subcommand matches enforced by clap.rs");
 
-  let now = SystemTime::now();
-  let result: Result<String, AppError> = match subcommand_name.as_ref() {
+  let result: Result<(), AppError> = match subcommand_name.as_ref() {
     "sync" => {
       let worker = subcommand_matches.get_one::<i32>("parallelism").expect("enforced by clap.rs").to_owned();
 
@@ -76,9 +74,7 @@ fn _main() -> i32 {
       let override_path: Option<String> = subcommand_matches.get_one::<String>("override-path").map(ToOwned::to_owned);
       project::update_entry(config, name, git, after_workon, after_clone, override_path)
     }
-    "setup" => setup::setup(
-      subcommand_matches.get_one::<String>("WORKSPACE_DIR").expect("argument required by clap.rs"),
-    ),
+    "setup" => setup::setup(subcommand_matches.get_one::<String>("WORKSPACE_DIR").expect("argument required by clap.rs")),
     "import" => setup::import(
       config,
       subcommand_matches.get_one::<String>("PROJECT_DIR").expect("argument required by clap.rs"),
@@ -141,25 +137,18 @@ fn _main() -> i32 {
     ),
     _ => Err(AppError::InternalError("Command not implemented")),
   }
-  .and_then(|_| now.elapsed().map_err(AppError::ClockError))
-  .map(|duration| format!("{}sec", duration.as_secs()));
+  .map(|_| ());
 
   match result {
-    Ok(time) => {
-      0
-    }
+    Ok(()) => 0,
     Err(error) => {
       eprintln!("Error running command: error {}", error);
       1
     }
   }
 }
 
-fn execute_tag_subcommand(
-  maybe_config: Result<config::Config, AppError>,
-  tag_command_name: &str,
-  tag_matches: &clap::ArgMatches,
-) -> Result<(), AppError> {
+fn execute_tag_subcommand(maybe_config: Result<config::Config, AppError>, tag_command_name: &str, tag_matches: &clap::ArgMatches) -> Result<(), AppError> {
   match tag_command_name {
     "ls" => {
       let maybe_project_name: Option<String> = tag_matches.get_one::<String>("PROJECT_NAME").map(ToOwned::to_owned);

src/project/mod.rs

@@ -55,11 +55,9 @@ pub fn add_entry(
 pub fn remove_project(maybe_config: Result<Config, AppError>, project_name: &str, purge_directory: bool) -> Result<(), AppError> {
   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)))
   } else if let Some(project) = config.projects.get(&project_name.to_owned()).cloned() {
-
     if purge_directory {
       let path = config.actual_path_to_project(&project);
 

src/projectile/mod.rs

@@ -15,10 +15,10 @@ pub fn projectile(maybe_config: Result<Config, AppError>) -> Result<(), AppError
   projectile_bookmarks.push(".emacs.d");
   projectile_bookmarks.push("projectile-bookmarks.eld");
   let writer = fs::File::create(projectile_bookmarks)?;
-  persist( &home_dir, writer, projects_paths)
+  persist(&home_dir, writer, projects_paths)
 }
 
-fn persist<W>( home_dir: &Path, writer: W, paths: Vec<PathBuf>) -> Result<(), AppError>
+fn persist<W>(home_dir: &Path, writer: W, paths: Vec<PathBuf>) -> Result<(), AppError>
 where
   W: io::Write,
 {
@@ -55,7 +55,7 @@ mod tests {
     let paths = vec![PathBuf::from("/home/mriehl/test"), PathBuf::from("/home/mriehl/go/src/github.com/test2")];
 
     let home_dir = Path::new("/home/blubb").to_path_buf();
-    persist( &home_dir, &mut buffer, paths).unwrap();
+    persist(&home_dir, &mut buffer, paths).unwrap();
 
     assert_eq!(
       str::from_utf8(buffer.get_ref()).unwrap(),
@@ -70,5 +70,4 @@ mod tests {
     let replaced_string = replace_path_with_tilde("/home/blubb/moep/home/blubb/test.txt", home_dir).expect("should succeed");
     assert_eq!(replaced_string, "~/moep/home/blubb/test.txt".to_string());
   }
-
 }