minor changes

Author: Fare-spec

src/fs_manager/mod.rs

@@ -41,15 +41,15 @@ fn create_server_properties() -> io::Result<()> {
     let path = Path::new(consts::file_paths::PROPERTIES);
     let content = consts::file_contents::server_properties();
 
-    utils::create_file(path, &content)
+    utils::create_file(path, Some(&content))
 }
 
 /// Creates the 'eula.txt' file if it does not already exist.
 fn create_eula() -> io::Result<()> {
     let path = Path::new(consts::file_paths::EULA);
     let content = consts::file_contents::eula();
 
-    utils::create_file(path, &content)
+    utils::create_file(path, Some(&content))
 }
 
 /// Check if the 'eula.txt' has been agreed to.
@@ -69,47 +69,47 @@ fn check_eula() -> io::Result<bool> {
 }
 
 pub fn create_other_files() {
-    match utils::create_file_nn(Path::new(consts::file_paths::BANNED_IP)) {
+    match utils::create_file(Path::new(consts::file_paths::BANNED_IP), None) {
         Ok(_) => (),
         Err(e) => error!(
             "Failed to create the file {} as error:{}",
             consts::file_paths::BANNED_IP,
             e
         ),
     }
-    match utils::create_file_nn(Path::new(consts::file_paths::BANNED_PLAYERS)) {
+    match utils::create_file(Path::new(consts::file_paths::BANNED_PLAYERS), None) {
         Ok(_) => (),
         Err(e) => error!(
             "Failed to create the file {} as error:{}",
             consts::file_paths::BANNED_PLAYERS,
             e
         ),
     }
-    match utils::create_file_nn(Path::new(consts::file_paths::OPERATORS)) {
+    match utils::create_file(Path::new(consts::file_paths::OPERATORS), None) {
         Ok(_) => (),
         Err(e) => error!(
             "Failed to create the file {} as error:{}",
             consts::file_paths::OPERATORS,
             e
         ),
     }
-    match utils::create_file_nn(Path::new(consts::file_paths::SESSION)) {
+    match utils::create_file(Path::new(consts::file_paths::SESSION), None) {
         Ok(_) => (),
         Err(e) => error!(
             "Failed to create the file {} as error:{}",
             consts::file_paths::SESSION,
             e
         ),
     }
-    match utils::create_file_nn(Path::new(consts::file_paths::USERCACHE)) {
+    match utils::create_file(Path::new(consts::file_paths::USERCACHE), None) {
         Ok(_) => (),
         Err(e) => error!(
             "Failed to create the file {} as error:{}",
             consts::file_paths::USERCACHE,
             e
         ),
     }
-    match utils::create_file_nn(Path::new(consts::file_paths::WHITELIST)) {
+    match utils::create_file(Path::new(consts::file_paths::WHITELIST), None) {
         Ok(_) => (),
         Err(e) => error!(
             "Failed to create the file {} as error:{}",

src/fs_manager/utils.rs

@@ -1,5 +1,4 @@
-use log::{debug, info};
-use std::fs::metadata;
+use log::info;
 use std::{
     fs::{self, File, OpenOptions},
     io::{self, Write},
@@ -8,63 +7,43 @@ use std::{
 
 /// Creates a file if it does not already exist.
 /// If the file already exists, it doesn't modify its content.
-pub fn create_file(path: &Path, content: &str) -> io::Result<()> {
+pub fn create_file(path: &Path, content: Option<&str>) -> io::Result<()> {
     match OpenOptions::new().write(true).create_new(true).open(path) {
-        Ok(mut file) => {
-            info!("File '{}' created.", path.to_string_lossy());
-            file.write_all(content.as_bytes())?;
-            Ok(())
-        }
+        Ok(mut file) => content.map_or_else(
+            || {
+                info!("Created an empty file: '{}'", path.display());
+                Ok(())
+            },
+            |s| {
+                file.write_all(s.as_bytes())
+                    .inspect(|_| info!("File '{}' created.", path.display()))
+            },
+        ),
         Err(e) if e.kind() == io::ErrorKind::AlreadyExists => {
-            info!(
-                "File '{}' already exists. Not altering it.",
-                path.to_string_lossy()
-            );
-            Ok(())
-        }
-        Err(e) => Err(e),
-    }
-}
-///Create_file with no content...
-pub fn create_file_nn(path: &Path) -> io::Result<()> {
-    // Verify if the file does not already exist.
-    if metadata(path).is_ok() {
-        info!(
-            "File '{}' already exists. Not altering it.",
-            path.to_string_lossy()
-        );
-        return Ok(());
-    }
-
-    // Create the file.
-    match std::fs::File::create(path) {
-        Ok(_) => {
-            info!("File '{}' created.", path.to_string_lossy());
+            info!("File '{}' already exists. Not altering it.", path.display());
             Ok(())
         }
         Err(e) => Err(e),
     }
 }
 
-/// Creates a file given its path.
+/// Creates a directory given its path.
 pub fn create_dir(path: &Path) -> io::Result<()> {
     if path.exists() {
         info!(
             "Directory '{}' already exists. Not altering it.",
-            path.to_string_lossy()
+            path.display()
         );
         return Ok(());
     }
-    fs::create_dir(path)?;
-    info!("Created directory: '{}'", path.to_string_lossy());
-    Ok(())
+    fs::create_dir(path).inspect(|_| info!("Created directory: '{}'", path.display()))
 }
 
 /// Opens an already existing file and overwrites all content with `content`.
 pub fn overwrite_file(path: &Path, content: &str) -> std::io::Result<()> {
     let mut file = File::create(path)?;
-    debug!("Overwrote file '{}'", path.to_string_lossy());
     file.write_all(content.as_bytes())
+        .inspect(|_| info!("Overwrote file: '{}'", path.display()))
 }
 
 #[cfg(test)]
@@ -107,18 +86,18 @@ mod tests {
         // Test 1: Create a new file
         let file_path = temp_dir.path().join("test1.txt");
         let content = "Hello, World!";
-        create_file(&file_path, content)?;
+        create_file(&file_path, Some(content))?;
         assert!(file_path.exists());
         assert_eq!(fs::read_to_string(&file_path)?, content);
 
         // Test 2: Attempt to create an existing file (should not modify)
         let existing_content = fs::read_to_string(&file_path)?;
-        create_file(&file_path, "New content")?;
+        create_file(&file_path, Some("New content"))?;
         assert_eq!(fs::read_to_string(&file_path)?, existing_content);
 
         // Test 3: Create file with empty content
         let empty_file_path = temp_dir.path().join("empty.txt");
-        create_file(&empty_file_path, "")?;
+        create_file(&empty_file_path, Some(""))?;
         assert!(empty_file_path.exists());
         assert_eq!(fs::read_to_string(&empty_file_path)?, "");