Merge branch 'master' of github.com:rage/tmc-langs-rust

Author: Heliozoa

plugins/csharp/src/plugin/policy.rs

@@ -1,6 +1,5 @@
 //! Student file policy for C#
 
-use std::ffi::OsString;
 use std::path::{Path, PathBuf};
 use tmc_langs_framework::StudentFilePolicy;
 
@@ -17,16 +16,12 @@ impl CSharpStudentFilePolicy {
 
     /// Goes up directories until a bin or obj directory is found
     fn is_child_of_binary_dir(&self, path: &Path) -> bool {
-        let mut parent = path.parent();
-        while let Some(next) = parent {
-            if let Some(file_name) = next.file_name() {
-                if next.is_dir()
-                    && (file_name == OsString::from("bin") || file_name == OsString::from("obj"))
-                {
+        for ancestor in path.ancestors() {
+            if let Some(file_name) = ancestor.file_name() {
+                if ancestor.is_dir() && (file_name == "bin" || file_name == "obj") {
                     return true;
                 }
             }
-            parent = next.parent();
         }
         false
     }
@@ -35,11 +30,7 @@ impl CSharpStudentFilePolicy {
 impl StudentFilePolicy for CSharpStudentFilePolicy {
     // false for files in bin or obj directories, true for other files in src
     fn is_student_source_file(&self, path: &Path) -> bool {
-        if self.is_child_of_binary_dir(path) {
-            false
-        } else {
-            path.starts_with("src")
-        }
+        path.starts_with("src") && !self.is_child_of_binary_dir(path)
     }
 
     fn get_config_file_parent_path(&self) -> &Path {

plugins/python3/src/policy.rs

@@ -50,6 +50,18 @@ mod test {
         assert!(policy.is_student_source_file(Path::new("src/some_file.py")));
     }
 
+    #[test]
+    fn in_root_is_source_file() {
+        let policy = Python3StudentFilePolicy::new(PathBuf::from(""));
+        assert!(policy.is_student_source_file(Path::new("some_file.py")));
+    }
+
+    #[test]
+    fn in_subdir_is_source_file() {
+        let policy = Python3StudentFilePolicy::new(PathBuf::from(""));
+        assert!(policy.is_student_source_file(Path::new("src/some_dir/some_file.py")));
+    }
+
     #[test]
     fn pycache_is_not_source_file() {
         let policy = Python3StudentFilePolicy::new(PathBuf::from(""));

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())