Apply cargo clippy

Author: linyinfeng

src/cache.rs

@@ -24,7 +24,7 @@ pub fn query(cache: &Connection, target: &str, commit: &str) -> Result<Option<bo
     let mut stmt = cache.prepare_cached(
         "SELECT is_parent FROM commits_cache WHERE target_commit = ?1 AND this_commit = ?2",
     )?;
-    log::trace!("query cache: ({}, {})", target, commit);
+    log::trace!("query cache: ({target}, {commit})");
     let query_result: Vec<bool> = stmt
         .query_map(params!(target, commit), |row| row.get(0))?
         .collect::<Result<_, _>>()?;
@@ -39,15 +39,15 @@ pub fn store(cache: &Connection, target: &str, commit: &str, hit: bool) -> Resul
     let mut stmt = cache.prepare_cached(
         "INSERT INTO commits_cache (target_commit, this_commit, is_parent) VALUES (?1, ?2, ?3)",
     )?;
-    log::trace!("insert new cache: ({}, {}, {})", target, commit, hit);
+    log::trace!("insert new cache: ({target}, {commit}, {hit})");
     let inserted = stmt.execute(params!(target, commit, hit))?;
     assert_eq!(inserted, 1);
     Ok(())
 }
 
 pub fn remove(cache: &Connection, target: &str) -> Result<(), Error> {
     let mut stmt = cache.prepare_cached("DELETE FROM commits_cache WHERE target_commit = ?1")?;
-    log::trace!("delete cache for target commit: {}", target);
+    log::trace!("delete cache for target commit: {target}");
     stmt.execute(params!(target))?;
     Ok(())
 }

src/main.rs

@@ -55,12 +55,12 @@ enum BCommand {
 }
 
 async fn answer(bot: Bot, msg: Message, bc: BCommand) -> ResponseResult<()> {
-    log::debug!("message: {:?}", msg);
-    log::trace!("bot command: {:?}", bc);
+    log::debug!("message: {msg:?}");
+    log::trace!("bot command: {bc:?}");
     let BCommand::Notifier(input) = bc;
     let result = match command::parse(input) {
         Ok(command) => {
-            log::debug!("command: {:?}", command);
+            log::debug!("command: {command:?}");
             let (bot, msg) = (bot.clone(), msg.clone());
             match command {
                 command::Notifier::RepoAdd { name, url } => repo_add(bot, msg, name, url).await,

src/repo.rs

@@ -51,7 +51,7 @@ pub struct ConditionCheckResult {
 }
 
 pub async fn create(name: &str, path: PathBuf, url: &str) -> Result<Output, Error> {
-    log::info!("try clone '{}' into {:?}", url, path);
+    log::info!("try clone '{url}' into {path:?}");
 
     let output = {
         let url = url.to_owned();
@@ -76,15 +76,15 @@ pub async fn create(name: &str, path: PathBuf, url: &str) -> Result<Output, Erro
     }
 
     let _repo = Repository::open(&path)?;
-    log::info!("cloned git repository {:?}", path);
+    log::info!("cloned git repository {path:?}");
 
     Ok(output)
 }
 
 pub async fn fetch(resources: Arc<Resources>) -> Result<Output, Error> {
     let paths = &resources.paths;
     let repo_path = &paths.repo;
-    log::info!("fetch {:?}", repo_path);
+    log::info!("fetch {repo_path:?}");
 
     let output = {
         let path = repo_path.clone();

src/repo/tasks.rs

@@ -181,10 +181,10 @@ where
     T: Serialize + DeserializeOwned + Default,
 {
     if !path.as_ref().is_file() {
-        log::info!("auto create file: {:?}", path);
+        log::info!("auto create file: {path:?}");
         write_json::<_, T>(&path, &Default::default())?;
     }
-    log::debug!("read from file: {:?}", path);
+    log::debug!("read from file: {path:?}");
     let file = File::open(path)?;
     // TODO lock_shared maybe added to the std lib in the future
     FileExt::lock_shared(&file)?; // close of file automatically release the lock
@@ -197,7 +197,7 @@ where
     P: AsRef<Path> + fmt::Debug,
     T: Serialize,
 {
-    log::debug!("write to file: {:?}", path);
+    log::debug!("write to file: {path:?}");
     let file = OpenOptions::new()
         .write(true)
         .create(true)