added move-projects-dir

Author: Heliozoa

tmc-langs-cli/src/app.rs

@@ -665,19 +665,41 @@ fn create_settings_app() -> App<'static, 'static> {
                         .takes_value(true),
                 ),
         )
-        .subcommand(
-            SubCommand::with_name("set")
-                .about("Saves a value in the settings")
-                .arg(Arg::with_name("key").help("The key."))
-                .arg(Arg::with_name("json").help("The value in JSON.")),
-        )
         .subcommand(
             SubCommand::with_name("list")
                 .about("Prints every key=value pair in the settings file."),
         )
+        .subcommand(
+            SubCommand::with_name("move-projects-dir")
+                .about(
+                    "Change the projects-dir setting, moving the contents into the new directory",
+                )
+                .arg(
+                    Arg::with_name("dir")
+                        .help("The directory where the projects should be moved.")
+                        .required(true)
+                        .takes_value(true),
+                ),
+        )
         .subcommand(
             SubCommand::with_name("reset").about("Resets the settings file to the defaults"),
         )
+        .subcommand(
+            SubCommand::with_name("set")
+                .about("Saves a value in the settings")
+                .arg(
+                    Arg::with_name("key")
+                        .help("The key. Parsed as JSON, assumed to be a string if parsing fails.")
+                        .required(true)
+                        .takes_value(true),
+                )
+                .arg(
+                    Arg::with_name("json")
+                        .help("The value in JSON.")
+                        .required(true)
+                        .takes_value(true),
+                ),
+        )
         .subcommand(
             SubCommand::with_name("unset")
                 .about("Unsets a value from the settings")

tmc-langs-cli/src/config.rs

@@ -1,12 +1,74 @@
 //! Handles the CLI's configuration files and credentials.
 
 use anyhow::{Context, Error};
+use serde::{Deserialize, Serialize};
 use std::env;
 use std::fs::{self, File};
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use toml::{value::Table, Value};
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct Config {
+    pub projects_dir: PathBuf,
+    #[serde(flatten)]
+    pub table: Table,
+}
+
+impl Config {
+    pub fn get(&self, key: &str) -> ConfigValue {
+        match key {
+            "projects-dir" => ConfigValue::Path(&self.projects_dir),
+            _ => ConfigValue::Value(self.table.get(key)),
+        }
+    }
+
+    pub fn insert(&mut self, key: String, value: Value) -> Result<(), anyhow::Error> {
+        match key.as_str() {
+            "projects-dir" => {
+                if let Value::String(value) = value {
+                    let path = PathBuf::from(value);
+                    self.set_projects_dir(path)?;
+                } else {
+                    anyhow::bail!("The value for projects-dir must be a string.")
+                }
+            }
+            _ => {
+                self.table.insert(key, value);
+            }
+        }
+        Ok(())
+    }
+
+    pub fn remove(&mut self, key: &str) -> Result<Option<Value>, anyhow::Error> {
+        match key {
+            "projects-dir" => anyhow::bail!("projects-dir must always be defined"),
+            _ => Ok(self.table.remove(key)),
+        }
+    }
+
+    pub fn set_projects_dir(&mut self, mut target: PathBuf) -> Result<PathBuf, anyhow::Error> {
+        // check if the directory is empty or not
+        if fs::read_dir(&target)
+            .with_context(|| format!("Failed to read directory at {}", target.display()))?
+            .next()
+            .is_some()
+        {
+            anyhow::bail!("Cannot set projects-dir to a non-empty directory.");
+        }
+        std::mem::swap(&mut self.projects_dir, &mut target);
+        Ok(target)
+    }
+}
+
+#[derive(Debug, Serialize)]
+#[serde(untagged)]
+pub enum ConfigValue<'a> {
+    Value(Option<&'a Value>),
+    Path(&'a Path),
+}
+
 // base directory for a given plugin's settings files
 fn get_tmc_dir(client_name: &str) -> Result<PathBuf, Error> {
     let config_dir = match env::var("TMC_LANGS_CONFIG_DIR") {
@@ -35,7 +97,7 @@ fn get_client_stub(client: &str) -> &str {
 }
 
 // initializes the default configuration file at the given path
-fn init_config_at(client_name: &str, path: &Path) -> Result<Table, Error> {
+fn init_config_at(client_name: &str, path: &Path) -> Result<Config, Error> {
     let mut file = File::create(&path)
         .with_context(|| format!("Failed to create new config file at {}", path.display()))?;
 
@@ -50,21 +112,20 @@ fn init_config_at(client_name: &str, path: &Path) -> Result<Table, Error> {
         )
     })?;
 
-    let mut config = Table::new();
-    config.insert(
-        "projects-folder".to_string(),
-        Value::String(default_project_dir.to_string_lossy().into_owned()),
-    );
+    let config = Config {
+        projects_dir: default_project_dir,
+        table: Table::new(),
+    };
 
     let toml = toml::to_string_pretty(&config).context("Failed to serialize config")?;
     file.write_all(toml.as_bytes())
         .with_context(|| format!("Failed to write default config to {}", path.display()))?;
     Ok(config)
 }
 
-pub fn load_config(client_name: &str) -> Result<Table, Error> {
+pub fn load_config(client_name: &str) -> Result<Config, Error> {
     let path = get_config_path(client_name)?;
-    match fs::read(&path) {
+    let config = match fs::read(&path) {
         Ok(bytes) => match toml::from_slice(&bytes) {
             Ok(config) => Ok(config),
             Err(_) => {
@@ -76,10 +137,19 @@ pub fn load_config(client_name: &str) -> Result<Table, Error> {
             }
         },
         Err(_) => init_config_at(client_name, &path),
+    }?;
+    if !config.projects_dir.exists() {
+        fs::create_dir_all(&config.projects_dir).with_context(|| {
+            format!(
+                "Failed to create projects-dir at {}",
+                config.projects_dir.display()
+            )
+        })?;
     }
+    Ok(config)
 }
 
-pub fn save_config(client_name: &str, config: Table) -> Result<(), Error> {
+pub fn save_config(client_name: &str, config: Config) -> Result<(), Error> {
     let path = get_config_path(client_name)?;
     let toml = toml::to_string_pretty(&config).context("Failed to serialize HashMap")?;
     fs::write(&path, toml.as_bytes())

tmc-langs-cli/src/main.rs

@@ -35,6 +35,7 @@ use tmc_langs_util::{
 };
 use toml::{map::Map as TomlMap, Value as TomlValue};
 use url::Url;
+use walkdir::WalkDir;
 
 #[quit::main]
 fn main() {
@@ -1415,7 +1416,7 @@ fn run_settings(
     warnings: &[anyhow::Error],
 ) -> Result<PrintToken> {
     let client_name = matches.value_of("client-name").unwrap();
-    let mut map = config::load_config(client_name)?;
+    let mut config = config::load_config(client_name)?;
 
     match matches.subcommand() {
         ("get", Some(matches)) => {
@@ -1425,37 +1426,156 @@ fn run_settings(
                 result: OutputResult::RetrievedData,
                 message: Some("Retrieved value".to_string()),
                 percent_done: 1.0,
-                data: map.get(key),
+                data: Some(config.get(key)),
             });
             print_output(&output, pretty, warnings)
         }
-        ("set", Some(matches)) => {
-            let key = matches.value_of("key").unwrap();
-            let value = matches.value_of("json").unwrap();
+        ("list", Some(_)) => {
+            let output = Output::OutputData(OutputData {
+                status: Status::Finished,
+                result: OutputResult::RetrievedData,
+                message: Some("Retrieved settings".to_string()),
+                percent_done: 1.0,
+                data: Some(config),
+            });
+            print_output(&output, pretty, warnings)
+        }
+        ("move-projects-dir", Some(matches)) => {
+            let dir = matches.value_of("dir").unwrap();
+            let target = PathBuf::from(dir);
 
-            let value = serde_json::from_str(value)
-                .with_context(|| format!("Failed to deserialize {} as JSON", value))?;
-            let value = json_to_toml(value)?;
+            if target.is_file() {
+                anyhow::bail!("The target path points to a file.")
+            }
+            if !target.exists() {
+                fs::create_dir_all(&target).with_context(|| {
+                    format!("Failed to create directory at {}", target.display())
+                })?;
+            }
+
+            let target_canon = target
+                .canonicalize()
+                .with_context(|| format!("Failed to canonicalize {}", target.display()))?;
+            let prev_dir_canon = config.projects_dir.canonicalize().with_context(|| {
+                format!("Failed to canonicalize {}", config.projects_dir.display())
+            })?;
+            if target_canon == prev_dir_canon {
+                anyhow::bail!(
+                    "Attempted to move the projects-dir to the directory it's already in."
+                )
+            }
+
+            let reporter = ProgressReporter::new(move |update| {
+                let output = Output::StatusUpdate::<()>(update);
+                print_output(&output, pretty, &[])?;
+                Ok(())
+            });
+
+            reporter
+                .progress("Moving projects-dir", 0.0, None)
+                .map_err(|e| anyhow::anyhow!(e))?;
+
+            let old_projects_dir = config.set_projects_dir(target.clone())?;
+            let mut file_count_copied = 0;
+            let mut file_count_total = 0;
+            for entry in WalkDir::new(&old_projects_dir) {
+                let entry = entry.with_context(|| {
+                    format!("Failed to read file inside {}", old_projects_dir.display())
+                })?;
+                if entry.path().is_file() {
+                    file_count_total += 1;
+                }
+            }
+            for entry in WalkDir::new(&old_projects_dir).contents_first(true) {
+                let entry = entry.with_context(|| {
+                    format!("Failed to read file inside {}", old_projects_dir.display())
+                })?;
+                let entry_path = entry.path();
+
+                if entry_path.is_file() {
+                    let relative = entry_path.strip_prefix(&old_projects_dir).unwrap();
+                    let target_path = target.join(relative);
+                    log::debug!(
+                        "Moving {} -> {}",
+                        entry_path.display(),
+                        target_path.display()
+                    );
+
+                    // create parent dir for target and copy it, remove source file after
+                    if let Some(parent) = target_path.parent() {
+                        fs::create_dir_all(parent).with_context(|| {
+                            format!("Failed to create directory at {}", parent.display())
+                        })?;
+                    }
+                    fs::copy(entry_path, &target_path).with_context(|| {
+                        format!(
+                            "Failed to copy file from {} to {}",
+                            entry_path.display(),
+                            target_path.display()
+                        )
+                    })?;
+                    fs::remove_file(entry_path).with_context(|| {
+                        format!(
+                            "Failed to remove file at {} after copying it",
+                            entry_path.display()
+                        )
+                    })?;
 
-            map.insert(key.to_string(), value);
-            config::save_config(client_name, map)?;
+                    file_count_copied += 1;
+                    reporter
+                        .progress(
+                            format!("Moved file {} / {}", file_count_copied, file_count_total),
+                            file_count_copied as f64 / file_count_total as f64,
+                            None,
+                        )
+                        .map_err(|e| anyhow::anyhow!(e))?;
+                } else if entry_path.is_dir() {
+                    log::debug!("Deleting {}", entry_path.display());
+                    fs::remove_dir(entry_path).with_context(|| {
+                        format!("Failed to remove directory at {}", entry_path.display())
+                    })?;
+                }
+            }
+
+            config::save_config(client_name, config)?;
+
+            reporter
+                .finish_step("Finished moving project directory", None)
+                .map_err(|e| anyhow::anyhow!(e))?;
 
             let output = Output::<()>::OutputData(OutputData {
                 status: Status::Finished,
                 result: OutputResult::ExecutedCommand,
-                message: Some("Set setting".to_string()),
+                message: Some("Moved project directory".to_string()),
                 percent_done: 1.0,
                 data: None,
             });
             print_output(&output, pretty, warnings)
         }
-        ("list", Some(_)) => {
-            let output = Output::OutputData(OutputData {
+        ("set", Some(matches)) => {
+            let key = matches.value_of("key").unwrap();
+            let value = matches.value_of("json").unwrap();
+
+            let value = match serde_json::from_str(value) {
+                Ok(json) => json,
+                Err(_) => {
+                    // interpret as string
+                    JsonValue::String(value.to_string())
+                }
+            };
+            let value = json_to_toml(value)?;
+
+            config
+                .insert(key.to_string(), value.clone())
+                .with_context(|| format!("Failed to set {} to {}", key, value))?;
+            config::save_config(client_name, config)?;
+
+            let output = Output::<()>::OutputData(OutputData {
                 status: Status::Finished,
-                result: OutputResult::RetrievedData,
-                message: Some("Retrieved settings".to_string()),
+                result: OutputResult::ExecutedCommand,
+                message: Some("Set setting".to_string()),
                 percent_done: 1.0,
-                data: Some(map),
+                data: None,
             });
             print_output(&output, pretty, warnings)
         }
@@ -1473,8 +1593,10 @@ fn run_settings(
         }
         ("unset", Some(matches)) => {
             let key = matches.value_of("setting").unwrap();
-            map.remove(key);
-            config::save_config(client_name, map)?;
+            config
+                .remove(key)
+                .with_context(|| format!("Failed to unset {}", key))?;
+            config::save_config(client_name, config)?;
 
             let output = Output::<()>::OutputData(OutputData {
                 status: Status::Finished,

tmc-langs-core/src/error.rs

@@ -35,8 +35,8 @@ pub enum CoreError {
     UrlParse(String, #[source] url::ParseError),
     #[error("Failed to write response to {0}")]
     HttpWriteResponse(PathBuf, #[source] reqwest::Error),
-    #[error("Failed to deserialize response as JSON")]
-    HttpJsonResponse(#[source] reqwest::Error),
+    #[error("Failed to deserialize response from {0} as JSON")]
+    HttpJsonResponse(Url, #[source] reqwest::Error),
 
     #[error("Already authenticated")]
     AlreadyAuthenticated,