clippy

Author: lovasoa

src/app_config.rs

@@ -34,20 +34,17 @@ impl AppConfig {
                     config_file
                 ));
             }
-            log::debug!("Loading configuration from file: {:?}", config_file);
+            log::debug!("Loading configuration from file: {config_file:?}");
             load_from_file(config_file)?
         } else if let Some(config_dir) = &cli.config_dir {
-            log::debug!("Loading configuration from directory: {:?}", config_dir);
+            log::debug!("Loading configuration from directory: {config_dir:?}");
             load_from_directory(config_dir)?
         } else {
             log::debug!("Loading configuration from environment");
             load_from_env()?
         };
         if let Some(web_root) = &cli.web_root {
-            log::debug!(
-                "Setting web root to value from the command line: {:?}",
-                web_root
-            );
+            log::debug!("Setting web root to value from the command line: {web_root:?}");
             config.web_root.clone_from(web_root);
         }
         if let Some(config_dir) = &cli.config_dir {
@@ -82,7 +79,7 @@ impl AppConfig {
             .validate()
             .context("The provided configuration is invalid")?;
 
-        log::debug!("Loaded configuration: {:#?}", config);
+        log::debug!("Loaded configuration: {config:#?}");
 
         Ok(config)
     }
@@ -305,7 +302,7 @@ fn cannonicalize_if_possible(path: &std::path::Path) -> PathBuf {
 /// This should be called only once at the start of the program.
 pub fn load_from_directory(directory: &Path) -> anyhow::Result<AppConfig> {
     let cannonical = cannonicalize_if_possible(directory);
-    log::debug!("Loading configuration from {:?}", cannonical);
+    log::debug!("Loading configuration from {cannonical:?}");
     let config_file = directory.join("sqlpage");
     let mut app_config = load_from_file(&config_file)?;
     app_config.configuration_directory = directory.into();
@@ -314,7 +311,7 @@ pub fn load_from_directory(directory: &Path) -> anyhow::Result<AppConfig> {
 
 /// Parses and loads the configuration from the given file.
 pub fn load_from_file(config_file: &Path) -> anyhow::Result<AppConfig> {
-    log::debug!("Loading configuration from file: {:?}", config_file);
+    log::debug!("Loading configuration from file: {config_file:?}");
     let config = Config::builder()
         .add_source(config::File::from(config_file).required(false))
         .add_source(env_config())
@@ -450,7 +447,7 @@ fn create_default_database(configuration_directory: &Path) -> String {
         }
     }
 
-    log::warn!("No DATABASE_URL provided, and {:?} is not writeable. Using a temporary in-memory SQLite database. All the data created will be lost when this server shuts down.", configuration_directory);
+    log::warn!("No DATABASE_URL provided, and {configuration_directory:?} is not writeable. Using a temporary in-memory SQLite database. All the data created will be lost when this server shuts down.");
     prefix + ":memory:?cache=shared"
 }
 
@@ -477,7 +474,7 @@ fn default_database_connection_acquire_timeout_seconds() -> f64 {
 
 fn default_web_root() -> PathBuf {
     std::env::current_dir().unwrap_or_else(|e| {
-        log::error!("Unable to get current directory: {}", e);
+        log::error!("Unable to get current directory: {e}");
         PathBuf::from(&std::path::Component::CurDir)
     })
 }

src/file_cache.rs

@@ -117,10 +117,10 @@ impl<T: AsyncFromStrWithState> FileCache<T> {
         path: &Path,
         privileged: bool,
     ) -> anyhow::Result<Arc<T>> {
-        log::trace!("Attempting to get from cache {:?}", path);
+        log::trace!("Attempting to get from cache {path:?}");
         if let Some(cached) = self.cache.read().await.get(path) {
             if app_state.config.environment.is_prod() && !cached.needs_check() {
-                log::trace!("Cache answer without filesystem lookup for {:?}", path);
+                log::trace!("Cache answer without filesystem lookup for {path:?}");
                 return Ok(Arc::clone(&cached.content));
             }
             match app_state
@@ -129,7 +129,7 @@ impl<T: AsyncFromStrWithState> FileCache<T> {
                 .await
             {
                 Ok(false) => {
-                    log::trace!("Cache answer with filesystem metadata read for {:?}", path);
+                    log::trace!("Cache answer with filesystem metadata read for {path:?}");
                     cached.update_check_time();
                     return Ok(Arc::clone(&cached.content));
                 }
@@ -138,7 +138,7 @@ impl<T: AsyncFromStrWithState> FileCache<T> {
             }
         }
         // Read lock is released
-        log::trace!("Loading and parsing {:?}", path);
+        log::trace!("Loading and parsing {path:?}");
         let file_contents = app_state
             .file_system
             .read_to_string(app_state, path, privileged)
@@ -170,19 +170,19 @@ impl<T: AsyncFromStrWithState> FileCache<T> {
         match parsed {
             Ok(value) => {
                 let new_val = Arc::clone(&value.content);
-                log::trace!("Writing to cache {:?}", path);
+                log::trace!("Writing to cache {path:?}");
                 self.cache.write().await.insert(PathBuf::from(path), value);
-                log::trace!("Done writing to cache {:?}", path);
-                log::trace!("{:?} loaded in cache", path);
+                log::trace!("Done writing to cache {path:?}");
+                log::trace!("{path:?} loaded in cache");
                 Ok(new_val)
             }
             Err(e) => {
                 log::trace!(
                     "Evicting {path:?} from the cache because the following error occurred: {e}"
                 );
-                log::trace!("Removing from cache {:?}", path);
+                log::trace!("Removing from cache {path:?}");
                 self.cache.write().await.remove(path);
-                log::trace!("Done removing from cache {:?}", path);
+                log::trace!("Done removing from cache {path:?}");
                 Err(e)
             }
         }

src/filesystem.rs

@@ -204,10 +204,7 @@ impl DbFsQueries {
             PgTimeTz::type_info().into(),
             <str as Type<Postgres>>::type_info().into(),
         ];
-        log::debug!(
-            "Preparing the database filesystem was_modified_query: {}",
-            was_modified_query
-        );
+        log::debug!("Preparing the database filesystem was_modified_query: {was_modified_query}");
         db.prepare_with(&was_modified_query, param_types).await
     }
 
@@ -220,10 +217,7 @@ impl DbFsQueries {
             make_placeholder(db_kind, 1),
         );
         let param_types: &[AnyTypeInfo; 1] = &[<str as Type<Postgres>>::type_info().into()];
-        log::debug!(
-            "Preparing the database filesystem read_file_query: {}",
-            read_file_query
-        );
+        log::debug!("Preparing the database filesystem read_file_query: {read_file_query}");
         db.prepare_with(&read_file_query, param_types).await
     }
 
@@ -300,7 +294,7 @@ impl DbFsQueries {
             (path,)
         );
         let result = query.fetch_optional(&app_state.db.connection).await;
-        log::debug!("DB File exists result: {:?}", result);
+        log::debug!("DB File exists result: {result:?}");
         result
             .map(|result| result.is_some())
             .with_context(|| format!("Unable to check if {path:?} exists in the database"))

src/render.rs

@@ -189,7 +189,7 @@ impl HeaderContext {
         if remove == Some(&json!(true)) || remove == Some(&json!(1)) {
             cookie.make_removal();
             self.response.cookie(cookie);
-            log::trace!("Removing cookie {}", name);
+            log::trace!("Removing cookie {name}");
             return Ok(self);
         }
 
@@ -225,7 +225,7 @@ impl HeaderContext {
                 _ => bail!("expires must be a string or a number"),
             }));
         }
-        log::trace!("Setting cookie {}", cookie);
+        log::trace!("Setting cookie {cookie}");
         self.response
             .append_header((header::SET_COOKIE, cookie.encoded().to_string()));
         Ok(self)
@@ -300,10 +300,10 @@ impl HeaderContext {
         let password_hash = take_object_str(&mut data, "password_hash");
         let password = take_object_str(&mut data, "password");
         if let (Some(password), Some(password_hash)) = (password, password_hash) {
-            log::debug!("Authentication with password_hash = {:?}", password_hash);
+            log::debug!("Authentication with password_hash = {password_hash:?}");
             match verify_password_async(password_hash, password).await? {
                 Ok(()) => return Ok(PageContext::Header(self)),
-                Err(e) => log::info!("Password didn't match: {}", e),
+                Err(e) => log::info!("Password didn't match: {e}"),
             }
         }
         log::debug!("Authentication failed");
@@ -405,7 +405,7 @@ impl AnyRenderBodyContext {
         }
     }
     pub async fn handle_error(&mut self, error: &anyhow::Error) -> anyhow::Result<()> {
-        log::error!("SQL error: {:?}", error);
+        log::error!("SQL error: {error:?}");
         match self {
             AnyRenderBodyContext::Html(render_context) => render_context.handle_error(error).await,
             AnyRenderBodyContext::Json(json_body_renderer) => {
@@ -766,7 +766,7 @@ impl<W: std::io::Write> HtmlRenderContext<W> {
 
     pub async fn handle_result_and_log<R>(&mut self, result: &anyhow::Result<R>) {
         if let Err(e) = self.handle_result(result).await {
-            log::error!("{}", e);
+            log::error!("{e}");
         }
     }
 
@@ -838,14 +838,14 @@ impl<W: std::io::Write> HtmlRenderContext<W> {
     }
 
     fn close_component(&mut self) -> anyhow::Result<()> {
-        if let Some(old_component) = self.current_component.as_mut().take() {
+        if let Some(old_component) = self.current_component.as_mut() {
             old_component.render_end(&mut self.writer)?;
         }
         Ok(())
     }
 
     pub async fn close(mut self) -> W {
-        if let Some(old_component) = self.current_component.as_mut().take() {
+        if let Some(old_component) = self.current_component.as_mut() {
             let res = old_component
                 .render_end(&mut self.writer)
                 .map_err(|e| format_err!("Unable to render the component closing: {e}"));

src/template_helpers.rs

@@ -588,7 +588,7 @@ mod tests {
     use handlebars::{JsonValue, PathAndJson, ScopedJson};
     use serde_json::Value;
 
-    const CONTENT_KEY: &'static str = "contents_md";
+    const CONTENT_KEY: &str = "contents_md";
 
     #[test]
     fn test_rfc2822_date() {
@@ -624,8 +624,8 @@ mod tests {
 
         use super::*;
 
-        const UNSAFE_MARKUP: &'static str = "<table><tr><td>";
-        const ESCAPED_UNSAFE_MARKUP: &'static str = "&lt;table&gt;&lt;tr&gt;&lt;td&gt;";
+        const UNSAFE_MARKUP: &str = "<table><tr><td>";
+        const ESCAPED_UNSAFE_MARKUP: &str = "&lt;table&gt;&lt;tr&gt;&lt;td&gt;";
         #[test]
         fn test_html_blocks_with_various_settings() {
             let helper = MarkdownHelper::default();
@@ -672,7 +672,7 @@ mod tests {
                     Some(ref preset) => &as_args_with_unsafe(&content, preset)[..],
                 };
 
-                match helper.call(&args) {
+                match helper.call(args) {
                     Ok(actual) => assert_eq!(
                         case.expected_output.unwrap(),
                         actual.as_str().unwrap(),

src/webserver/database/connect.rs

@@ -172,7 +172,7 @@ fn add_on_connection_handler(
 fn set_custom_connect_options(options: &mut AnyConnectOptions, config: &AppConfig) {
     if let Some(sqlite_options) = options.as_sqlite_mut() {
         for extension_name in &config.sqlite_extensions {
-            log::info!("Loading SQLite extension: {}", extension_name);
+            log::info!("Loading SQLite extension: {extension_name}");
             *sqlite_options = std::mem::take(sqlite_options).extension(extension_name.clone());
         }
         *sqlite_options = std::mem::take(sqlite_options)

src/webserver/database/execute_queries.rs

@@ -53,7 +53,7 @@ pub fn stream_query_results_with_conn<'a>(
             match res {
                 ParsedStatement::CsvImport(csv_import) => {
                     let connection = take_connection(&request.app_state.db, db_connection).await?;
-                    log::debug!("Executing CSV import: {:?}", csv_import);
+                    log::debug!("Executing CSV import: {csv_import:?}");
                     run_csv_import(connection, csv_import, request).await.with_context(|| format!("Failed to import the CSV file {:?} into the table {:?}", csv_import.uploaded_file, csv_import.table_name))?;
                 },
                 ParsedStatement::StmtWithParams(stmt) => {
@@ -269,7 +269,7 @@ fn parse_single_sql_result(
             DbItem::Row(super::sql_to_json::row_to_json(&r))
         }
         Ok(Either::Left(res)) => {
-            log::debug!("Finished query with result: {:?}", res);
+            log::debug!("Finished query with result: {res:?}");
             DbItem::FinishedQuery
         }
         Err(err) => {
@@ -296,7 +296,7 @@ fn debug_row(r: &AnyRow) {
             .unwrap();
         }
     }
-    log::trace!("Received db row: {}", row_str);
+    log::trace!("Received db row: {row_str}");
 }
 
 fn clone_anyhow_err(source_file: &Path, err: &anyhow::Error) -> anyhow::Error {
@@ -313,7 +313,7 @@ async fn bind_parameters<'a>(
     db_connection: &mut DbConn,
 ) -> anyhow::Result<StatementWithParams<'a>> {
     let sql = stmt.query.as_str();
-    log::debug!("Preparing statement: {}", sql);
+    log::debug!("Preparing statement: {sql}");
     let mut arguments = AnyArguments::default();
     for (param_idx, param) in stmt.params.iter().enumerate() {
         log::trace!("\tevaluating parameter {}: {}", param_idx + 1, param);

src/webserver/database/sql.rs

@@ -32,7 +32,7 @@ impl ParsedSqlFile {
     #[must_use]
     pub fn new(db: &Database, sql: &str, source_path: &Path) -> ParsedSqlFile {
         let dialect = dialect_for_db(db.connection.any_kind());
-        log::debug!("Parsing SQL file {:?}", source_path);
+        log::debug!("Parsing SQL file {source_path:?}");
         let parsed_statements = match parse_sql(dialect.as_ref(), sql) {
             Ok(parsed) => parsed,
             Err(err) => return Self::from_err(err, source_path),
@@ -566,7 +566,7 @@ impl ParameterExtractor {
             db_kind,
             parameters: vec![],
         };
-        sql_ast.visit(&mut this);
+        let _ = sql_ast.visit(&mut this);
         this.parameters
     }
 

src/webserver/database/sql_to_json.rs

@@ -28,12 +28,12 @@ pub fn sql_to_json(row: &AnyRow, col: &sqlx::any::AnyColumn) -> Value {
                     .take()
                     .unwrap_or_else(|| row.try_get_raw(col.ordinal()).unwrap())
             });
-            log::trace!("Decoded value: {:?}", decoded);
+            log::trace!("Decoded value: {decoded:?}");
             decoded
         }
         Ok(_null) => Value::Null,
         Err(e) => {
-            log::warn!("Unable to extract value from row: {:?}", e);
+            log::warn!("Unable to extract value from row: {e:?}");
             Value::Null
         }
     }

src/webserver/database/sqlpage_functions/functions.rs

@@ -424,7 +424,7 @@ async fn persist_uploaded_file<'a>(
         return Ok(None);
     };
     let file_name = uploaded_file.file_name.as_deref().unwrap_or_default();
-    let extension = file_name.split('.').last().unwrap_or_default();
+    let extension = file_name.split('.').next_back().unwrap_or_default();
     if !allowed_extensions
         .clone()
         .any(|x| x.eq_ignore_ascii_case(extension))
@@ -446,14 +446,22 @@ async fn persist_uploaded_file<'a>(
     tokio::fs::copy(&uploaded_file.file.path(), &target_path)
         .await
         .with_context(|| {
-            format!("unable to copy uploaded file {field_name:?} to {target_path:?}")
+            format!(
+                "unable to copy uploaded file {field_name:?} to \"{}\"",
+                target_path.display()
+            )
         })?;
     // remove the WEB_ROOT prefix from the path, but keep the leading slash
     let path = "/".to_string()
         + target_path
             .strip_prefix(web_root)?
             .to_str()
-            .with_context(|| format!("unable to convert path {target_path:?} to a string"))?;
+            .with_context(|| {
+                format!(
+                    "unable to convert path \"{}\" to a string",
+                    target_path.display()
+                )
+            })?;
     Ok(Some(path))
 }
 
@@ -497,7 +505,7 @@ async fn read_file_bytes(request: &RequestInfo, path_str: &str) -> Result<Vec<u8
     } else {
         tokio::fs::read(path)
             .await
-            .with_context(|| format!("Unable to read file {path:?}"))
+            .with_context(|| format!("Unable to read file \"{}\"", path.display()))
     }
 }
 
@@ -609,7 +617,7 @@ async fn run_sql<'a>(
         use crate::webserver::database::DbItem::{Error, FinishedQuery, Row};
         match db_item {
             Row(row) => {
-                log::debug!("run_sql: row: {:?}", row);
+                log::debug!("run_sql: row: {row:?}");
                 seq.serialize_element(&row)?;
             }
             FinishedQuery => log::trace!("run_sql: Finished query"),
@@ -736,7 +744,7 @@ async fn request_body(request: &RequestInfo) -> Option<String> {
 /// application/x-www-form-urlencoded or multipart/form-data (in this case, the body is accessible via the `post_variables` field).
 async fn request_body_base64(request: &RequestInfo) -> Option<String> {
     let raw_body = request.raw_body.as_ref()?;
-    let mut base64_string = String::with_capacity((raw_body.len() * 4 + 2) / 3);
+    let mut base64_string = String::with_capacity((raw_body.len() * 4).div_ceil(3));
     base64::Engine::encode_string(
         &base64::engine::general_purpose::STANDARD,
         raw_body,