replace println to logger

Signed-off-by: scepter914 <scepter914@gmail.com>

Author: scepter914

Cargo.lock

@@ -17,6 +17,8 @@ toml = "0.9.8"
 walkdir = "2.5.0"
 glob = "0.3.3"
 chrono = "0.4.43"
+log = "0.4.29"
+env_logger = "0.11.8"
 
 [dev-dependencies]
 assert_cmd = "2.1.1"

Cargo.toml

@@ -7,11 +7,11 @@ pub fn check_required_files(config: &RackConfig, target_directory_path: &Path) {
     for required_filename in &config.artifact.required_files {
         let required_file_path = target_directory_path.join(required_filename);
         if !required_file_path.exists() {
-            eprintln!("Required file of {:?} is missing", required_file_path);
+            log::error!("Required file of {:?} is missing", required_file_path);
             std::process::exit(1);
         }
     }
-    println!("Required files are present");
+    log::info!("All required files are confirmed");
 }
 
 pub fn check_optional_files(config: &RackConfig, target_directory_path: &PathBuf) {
@@ -31,12 +31,12 @@ pub fn check_optional_files(config: &RackConfig, target_directory_path: &PathBuf
         if !config.artifact.is_required_file(&file_path)
             && !config.artifact.is_optional_file(&file_path)
         {
-            eprintln!("File {:?} is neither required nor optional", file_path);
+            log::error!("File {:?} is neither required nor optional", file_path);
             std::process::exit(1);
         }
     }
 
-    println!("All files are required files or optional files");
+    log::info!("All files are required files or optional files");
 }
 
 pub fn check_version(config: &RackConfig, config_dir: &PathBuf, target_directory_path: &Path) {
@@ -48,28 +48,29 @@ pub fn check_version(config: &RackConfig, config_dir: &PathBuf, target_directory
         .project
         .is_valid_version(&target_directory_path_from_config_dir)
     {
-        println!("Version format is valid");
+        log::info!("Version format is valid");
     } else {
-        eprintln!(
+        log::error!(
             "Version format is invalid at {:?}. Please check ProjectConfig of {:?} ",
-            target_directory_path_from_config_dir, config.project
+            target_directory_path_from_config_dir,
+            config.project
         );
         std::process::exit(1);
     }
 }
 
 pub fn write_result_to_readme(config: &RackConfig, target_directory_path: &PathBuf) {
     if config.document.template_file.is_some() {
-        println!("Write result of {:?} to README", target_directory_path);
+        log::info!("Write result of {:?} to README", target_directory_path);
     }
 }
 
 pub fn check(target_directory_path: PathBuf) {
     if !target_directory_path.exists() {
-        eprintln!("{:?} does not exist", target_directory_path);
+        log::error!("{:?} does not exist", target_directory_path);
         std::process::exit(1);
     } else {
-        println!(
+        log::info!(
             "Checking artifacts in rack at {:?}",
             target_directory_path.display()
         );
@@ -78,6 +79,5 @@ pub fn check(target_directory_path: PathBuf) {
         check_optional_files(&config, &target_directory_path);
         check_version(&config, &config_dir, &target_directory_path);
         write_result_to_readme(&config, &target_directory_path);
-        println!("All artifacts are valid.");
     }
 }

src/bin/ml-cellar/check.rs

@@ -12,14 +12,14 @@ pub fn clone(repository: String) {
 
     match status {
         Ok(s) if s.success() => {
-            println!("git clone done");
+            log::info!("git clone done");
         }
         Ok(s) => {
-            eprintln!("git clone failed: {s}");
+            log::error!("git clone failed: {s}");
             std::process::exit(1);
         }
         Err(e) => {
-            eprintln!("failed to execute git: {e}");
+            log::error!("failed to execute git: {e}");
             std::process::exit(1);
         }
     }

src/bin/ml-cellar/clone.rs

@@ -15,14 +15,14 @@ pub fn init() {
 
     match status {
         Ok(s) if s.success() => {
-            println!("git init done");
+            log::info!("git init done");
         }
         Ok(s) => {
-            eprintln!("git init failed: {s}");
+            log::error!("git init failed: {s}");
             std::process::exit(1);
         }
         Err(e) => {
-            eprintln!("failed to execute git: {e}");
+            log::error!("failed to execute git: {e}");
             std::process::exit(1);
         }
     }
@@ -39,14 +39,14 @@ pub fn init() {
 
     match status {
         Ok(s) if s.success() => {
-            println!("git branch -M main done");
+            log::info!("git branch -M main done");
         }
         Ok(s) => {
-            eprintln!("git branch -M failed: {s}");
+            log::error!("git branch -M failed: {s}");
             std::process::exit(1);
         }
         Err(e) => {
-            eprintln!("failed to execute git: {e}");
+            log::error!("failed to execute git: {e}");
             std::process::exit(1);
         }
     }

src/bin/ml-cellar/init.rs

@@ -1,4 +1,5 @@
 use clap::{Parser, Subcommand};
+use env_logger::Env;
 use std::path::PathBuf;
 
 mod check;
@@ -45,6 +46,8 @@ enum Commands {
     },
 }
 fn main() {
+    env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();
+
     let cli = Cli::parse();
     match cli.command {
         Commands::Init {} => {

src/bin/ml-cellar/main.rs

@@ -12,14 +12,14 @@ pub fn materialize_all() {
 
     match status {
         Ok(s) if s.success() => {
-            println!("git lfs pull done");
+            log::info!("git lfs pull done");
         }
         Ok(s) => {
-            eprintln!("git lfs pull failed: {s}");
+            log::error!("git lfs pull failed: {s}");
             std::process::exit(1);
         }
         Err(e) => {
-            eprintln!("failed to execute git: {e}");
+            log::error!("failed to execute git: {e}");
             std::process::exit(1);
         }
     }
@@ -38,14 +38,14 @@ pub fn materialize(path: PathBuf) {
 
     match status {
         Ok(s) if s.success() => {
-            println!("git lfs pull -I {} done", path.display());
+            log::info!("git lfs pull -I {} done", path.display());
         }
         Ok(s) => {
-            eprintln!("git lfs pull failed: {s}");
+            log::error!("git lfs pull failed: {s}");
             std::process::exit(1);
         }
         Err(e) => {
-            eprintln!("failed to execute git: {e}");
+            log::error!("failed to execute git: {e}");
             std::process::exit(1);
         }
     }

src/bin/ml-cellar/materialize.rs

@@ -6,13 +6,13 @@ use ml_cellar::rack::RackConfig;
 
 pub fn rack(path: PathBuf) {
     if path.exists() {
-        eprintln!("{:?} already exists", path);
+        log::error!("{:?} already exists", path);
         std::process::exit(1);
     } else {
         let rack_name = path.file_name().unwrap().to_str().unwrap();
 
         std::fs::create_dir_all(&path).expect("failed to create the directory for the rack");
-        println!("Create rack at {}", path.display());
+        log::info!("Create rack at {}", path.display());
 
         // Make README.md
         let readme_path = path.join("README.md");

src/bin/ml-cellar/rack.rs

@@ -151,14 +151,14 @@ pub fn load_config(path: &std::path::Path) -> (RackConfig, PathBuf) {
         let candidate = dir.join("config.toml");
         if candidate.is_file() {
             // Found config.toml, read and parse it
-            println!("Loading config from {:?}", candidate);
+            log::info!("Loading config from {:?}", candidate);
             let config_content = std::fs::read_to_string(&candidate).unwrap();
             return (toml::from_str(&config_content).unwrap(), dir);
         }
         match dir.parent() {
             Some(parent) => dir = parent.to_path_buf(),
             None => {
-                eprintln!(
+                log::error!(
                     "config.toml not found; reached filesystem root at {:?}",
                     dir
                 );