Cargo.toml

@@ -14,13 +14,9 @@ console-subscriber = "0.2"
 tracing = "0.1"
 tracing-subscriber = "0.3"
 
-# fs
-tempfile = "3.10"
-
 [dev-dependencies]
-# Testing
+# Conventional commits githook
-test-log = "0.2"
+cc-cli = "0.1.5"
 
 [package.metadata.bin]
-# Conventional commits githook
 cc-cli = { version = "0.1" }

src/filesystem.rs

@@ -1,128 +0,0 @@
-#![allow(unused)]
-
-use std::{
-    ops::Deref,
-    path::PathBuf,
-    sync::{Arc, Mutex},
-};
-
-use tempfile::{tempdir, TempDir};
-use tracing::{event, Level};
-
-#[derive(Clone, Debug)]
-pub enum FileSystem {
-    Real(RealFileSystemEnv),
-    Temp(TempFileSystemEnv),
-}
-impl FileSystem {
-    pub fn new_real(cwd: Option<PathBuf>) -> Self {
-        let cwd = cwd.unwrap_or_default();
-        Self::Real(RealFileSystemEnv::new(cwd))
-    }
-    pub fn new_temp() -> std::io::Result<Self> {
-        TempFileSystemEnv::new().map(Self::Temp)
-    }
-}
-impl Deref for FileSystem {
-    type Target = dyn FileSystemEnv;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            Self::Real(env) => env,
-            Self::Temp(env) => env,
-        }
-    }
-}
-
-pub trait FileSystemEnv: Sync + Send + std::fmt::Debug {
-    fn cwd(&self) -> &PathBuf;
-
-    fn in_cwd(&self, name: &str) -> PathBuf {
-        self.cwd().join(name)
-    }
-
-    fn write_file(&self, file_name: &str, content: &str) -> std::io::Result<PathBuf> {
-        use std::fs::File;
-        use std::io::{LineWriter, Write};
-
-        let path = self.in_cwd(file_name);
-        event!(Level::INFO, "writing to {:?}", path);
-        let file = File::create(path.clone())?;
-        let mut file = LineWriter::new(file);
-        file.write_all(content.as_bytes())?;
-        Ok(path)
-    }
-
-    fn file_exists(&self, name: &PathBuf) -> bool {
-        use std::fs::File;
-        File::open(name).is_ok()
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct RealFileSystemEnv {
-    cwd: PathBuf,
-}
-
-#[derive(Clone, Debug)]
-pub struct TempFileSystemEnv {
-    cwd: PathBuf,
-    temp_dir: Arc<Mutex<TempDir>>,
-}
-
-impl FileSystemEnv for TempFileSystemEnv {
-    fn cwd(&self) -> &PathBuf {
-        &self.cwd
-    }
-}
-
-impl FileSystemEnv for RealFileSystemEnv {
-    fn cwd(&self) -> &PathBuf {
-        &self.cwd
-    }
-}
-
-impl RealFileSystemEnv {
-    const fn new(cwd: PathBuf) -> Self {
-        Self { cwd }
-    }
-}
-
-impl TempFileSystemEnv {
-    fn new() -> std::io::Result<Self> {
-        let temp_dir = tempdir()?;
-        event!(Level::INFO, "temp dir: {:?}", temp_dir.path());
-        let cwd = temp_dir.path().to_path_buf();
-        let temp_dir = Arc::new(Mutex::new(temp_dir));
-        Ok(Self { cwd, temp_dir })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use super::*;
-
-    use std::path::PathBuf;
-
-    #[test_log::test]
-    fn test_cwd() {
-        let cwd = PathBuf::from("/tmp");
-        let env = RealFileSystemEnv::new(cwd.clone());
-        assert_eq!(env.cwd(), &cwd);
-    }
-
-    #[test_log::test]
-    fn test_create_on_temp_fs() -> std::io::Result<()> {
-        let env = TempFileSystemEnv::new()?;
-        assert!(env.cwd().exists());
-        Ok(())
-    }
-
-    #[test_log::test]
-    fn test_create_on_real_fs() {
-        let cwd = PathBuf::from("/tmp");
-        let env = RealFileSystemEnv::new(cwd.clone());
-        assert_eq!(env.cwd(), &cwd);
-    }
-}

src/init.rs

@@ -1,22 +1,26 @@
-use std::path::PathBuf;
+use std::io::Write;
 
-use crate::filesystem::FileSystem;
+pub(crate) fn run() {
-
-pub(crate) fn run(fs: FileSystem) {
     let file_name = ".git-next.toml";
-    let path = PathBuf::from(file_name);
+    let path = std::path::Path::new(file_name);
-    if fs.file_exists(&path) {
+    if path.exists() {
         eprintln!(
             "The configuration file already exists at {} - not overwritting it.",
             file_name
         );
     } else {
-        match fs.write_file(file_name, include_str!("../default.toml")) {
+        match std::fs::File::create(file_name) {
-            Ok(_) => {
+            Ok(mut file) => {
                 println!("Created a default configuration file at {}", file_name);
+                match file.write_all(include_bytes!("../default.toml")) {
+                    Ok(_) => println!("Wrote to the configuration file successfully."),
+                    Err(e) => {
+                        eprintln!("Failed to write to the configuration file: {}", e)
+                    }
+                }
             }
             Err(e) => {
-                eprintln!("Failed to write to the configuration file: {}", e)
+                eprintln!("Failed to create a default configuration file: {}", e);
             }
         }
     }

src/main.rs

@@ -1,4 +1,3 @@
-mod filesystem;
 mod init;
 mod server;
 
@@ -22,19 +21,18 @@ enum Server {
     Start,
 }
 fn main() {
-    let fs = filesystem::FileSystem::new_real(None);
     let commands = Commands::parse();
 
     match commands.command {
         Command::Init => {
-            init::run(fs);
+            init::run();
         }
         Command::Server(server) => match server {
             Server::Init => {
-                server::init(fs);
+                server::init();
             }
             Server::Start => {
-                server::start(fs);
+                server::start();
             }
         },
     }

src/server.rs

@@ -1,28 +1,34 @@
-use std::path::PathBuf;
+use std::io::Write;
 
 use tracing::info;
 
-use crate::filesystem::FileSystem;
+pub(crate) fn init() {
-
-pub(crate) fn init(fs: FileSystem) {
     let file_name = "git-next-server.toml";
-    let path = PathBuf::from(file_name);
+    let path = std::path::Path::new(file_name);
-    if fs.file_exists(&path) {
+    if path.exists() {
         eprintln!(
             "The configuration file already exists at {} - not overwritting it.",
             file_name
         );
     } else {
-        match fs.write_file(file_name, include_str!("../server-default.toml")) {
+        match std::fs::File::create(file_name) {
-            Ok(_) => println!("Created a default configuration file at {}", file_name),
+            Ok(mut file) => {
+                println!("Created a default configuration file at {}", file_name);
+                match file.write_all(include_bytes!("../server-default.toml")) {
+                    Ok(_) => println!("Wrote to the configuration file successfully."),
+                    Err(e) => {
+                        eprintln!("Failed to write to the configuration file: {}", e)
+                    }
+                }
+            }
             Err(e) => {
-                eprintln!("Failed to write to the configuration file: {}", e)
+                eprintln!("Failed to create a default configuration file: {}", e);
             }
         }
     }
 }
 
-pub(crate) fn start(_fs: FileSystem) {
+pub(crate) fn start() {
     let Ok(_) = init_logging() else {
         eprintln!("Failed to initialize logging.");
         return;