@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.2

package/rust/config/driver.rs

@@ -1,103 +1,112 @@
-use devalang_types::{
-    PluginEntry as SharedPluginEntry, ProjectConfig as SharedProjectConfig,
-    ProjectConfigBankEntry as SharedProjectConfigBankEntry,
-    ProjectConfigDefaults as SharedProjectConfigDefaults,
-    ProjectConfigPluginEntry as SharedProjectConfigPluginEntry,
-};
-use devalang_utils::path as path_utils;
-use std::path::PathBuf;
-
-pub type ProjectConfig = SharedProjectConfig;
-pub type ProjectConfigDefaults = SharedProjectConfigDefaults;
-pub type ProjectConfigBankEntry = SharedProjectConfigBankEntry;
-pub type ProjectConfigPluginEntry = SharedProjectConfigPluginEntry;
-pub type PluginEntry = SharedPluginEntry;
-
-pub trait ProjectConfigExt {
-    fn new_config() -> Self;
-    fn with_defaults(
-        entry: Option<String>,
-        output: Option<String>,
-        watch: Option<bool>,
-        repeat: Option<bool>,
-        debug: Option<bool>,
-        compress: Option<bool>,
-    ) -> Self;
-    fn get() -> Result<Self, String>
-    where
-        Self: Sized;
-    fn from_string(config_string: &str) -> Result<(Self, String), String>
-    where
-        Self: Sized;
-    fn write_config(&self, new_config: &Self) -> Result<(), String>
-    where
-        Self: Sized;
-}
-
-impl ProjectConfigExt for SharedProjectConfig {
-    fn new_config() -> Self {
-        SharedProjectConfig::default()
-    }
-
-    fn with_defaults(
-        entry: Option<String>,
-        output: Option<String>,
-        watch: Option<bool>,
-        repeat: Option<bool>,
-        debug: Option<bool>,
-        compress: Option<bool>,
-    ) -> Self {
-        SharedProjectConfig {
-            defaults: SharedProjectConfigDefaults {
-                entry,
-                output,
-                watch,
-                repeat,
-                debug,
-                compress,
-            },
-            banks: Some(Vec::new()),
-            plugins: Some(Vec::new()),
-        }
-    }
-
-    fn get() -> Result<Self, String> {
-        let config_path = path_utils::get_devalang_config_path()?;
-
-        let config_content = std::fs::read_to_string(&config_path)
-            .map_err(|e| format!("Failed to read config file: {}", e))?;
-
-        let config: SharedProjectConfig = toml::from_str(&config_content)
-            .map_err(|e| format!("Failed to parse config file: {}", e))?;
-
-        Ok(config)
-    }
-
-    fn from_string(config_string: &str) -> Result<(Self, String), String> {
-        let config: SharedProjectConfig = toml::from_str(config_string)
-            .map_err(|e| format!("Failed to parse config string: {}", e))?;
-        let config_path = ".devalang".to_string();
-
-        Ok((config, config_path))
-    }
-
-    fn write_config(&self, new_config: &Self) -> Result<(), String> {
-        let config_path: PathBuf = match path_utils::get_project_root() {
-            Ok(root) => root.join(path_utils::DEVALANG_CONFIG),
-            Err(_) => PathBuf::from(path_utils::DEVALANG_CONFIG),
-        };
-
-        let content = toml::to_string(new_config)
-            .map_err(|e| format!("Failed to serialize config: {}", e))?;
-
-        std::fs::write(&config_path, content).map_err(|e| {
-            format!(
-                "Failed to write config to file '{}': {}",
-                config_path.display(),
-                e
-            )
-        })?;
-
-        Ok(())
-    }
-}
+use devalang_types::{
+    PluginEntry as SharedPluginEntry, ProjectConfig as SharedProjectConfig,
+    ProjectConfigBankEntry as SharedProjectConfigBankEntry,
+    ProjectConfigDefaults as SharedProjectConfigDefaults,
+    ProjectConfigPluginEntry as SharedProjectConfigPluginEntry,
+};
+use devalang_utils::path as path_utils;
+use std::path::PathBuf;
+
+pub type ProjectConfig = SharedProjectConfig;
+pub type ProjectConfigDefaults = SharedProjectConfigDefaults;
+pub type ProjectConfigBankEntry = SharedProjectConfigBankEntry;
+pub type ProjectConfigPluginEntry = SharedProjectConfigPluginEntry;
+pub type PluginEntry = SharedPluginEntry;
+
+pub trait ProjectConfigExt {
+    fn new_config() -> Self;
+    fn with_defaults(
+        entry: Option<String>,
+        output: Option<String>,
+        watch: Option<bool>,
+        repeat: Option<bool>,
+        debug: Option<bool>,
+        compress: Option<bool>,
+        sample_rate: Option<u32>,
+        audio_format: Option<String>,
+        output_format: Option<Vec<String>>,
+    ) -> Self;
+    fn get() -> Result<Self, String>
+    where
+        Self: Sized;
+    fn from_string(config_string: &str) -> Result<(Self, String), String>
+    where
+        Self: Sized;
+    fn write_config(&self, new_config: &Self) -> Result<(), String>
+    where
+        Self: Sized;
+}
+
+impl ProjectConfigExt for SharedProjectConfig {
+    fn new_config() -> Self {
+        SharedProjectConfig::default()
+    }
+
+    fn with_defaults(
+        entry: Option<String>,
+        output: Option<String>,
+        watch: Option<bool>,
+        repeat: Option<bool>,
+        debug: Option<bool>,
+        compress: Option<bool>,
+        sample_rate: Option<u32>,
+        audio_format: Option<String>,
+        output_format: Option<Vec<String>>,
+    ) -> Self {
+        SharedProjectConfig {
+            defaults: SharedProjectConfigDefaults {
+                entry,
+                output,
+                watch,
+                repeat,
+                debug,
+                compress,
+                sample_rate,
+                audio_format,
+                output_format,
+            },
+            banks: Some(Vec::new()),
+            plugins: Some(Vec::new()),
+        }
+    }
+
+    fn get() -> Result<Self, String> {
+        let config_path = path_utils::get_devalang_config_path()?;
+
+        let config_content = std::fs::read_to_string(&config_path)
+            .map_err(|e| format!("Failed to read config file: {}", e))?;
+
+        let config: SharedProjectConfig = toml::from_str(&config_content)
+            .map_err(|e| format!("Failed to parse config file: {}", e))?;
+
+        Ok(config)
+    }
+
+    fn from_string(config_string: &str) -> Result<(Self, String), String> {
+        let config: SharedProjectConfig = toml::from_str(config_string)
+            .map_err(|e| format!("Failed to parse config string: {}", e))?;
+        let config_path = ".devalang".to_string();
+
+        Ok((config, config_path))
+    }
+
+    fn write_config(&self, new_config: &Self) -> Result<(), String> {
+        let config_path: PathBuf = match path_utils::get_project_root() {
+            Ok(root) => root.join(path_utils::DEVALANG_CONFIG),
+            Err(_) => PathBuf::from(path_utils::DEVALANG_CONFIG),
+        };
+
+        let content = toml::to_string(new_config)
+            .map_err(|e| format!("Failed to serialize config: {}", e))?;
+
+        std::fs::write(&config_path, content).map_err(|e| {
+            format!(
+                "Failed to write config to file '{}': {}",
+                config_path.display(),
+                e
+            )
+        })?;
+
+        Ok(())
+    }
+}

package/rust/config/mod.rs

@@ -1,3 +1,3 @@
-pub mod driver;
-pub mod ops;
-pub mod settings;
+pub mod driver;
+pub mod ops;
+pub mod settings;

package/rust/config/ops.rs

@@ -1,26 +1,26 @@
-use crate::config::driver::ProjectConfig;
-use std::fs;
-use std::path::Path;
-
-pub fn load_config(path: Option<&Path>) -> Option<ProjectConfig> {
-    let config_path_buf;
-    let config_path = match path {
-        Some(p) => p,
-        None => {
-            config_path_buf = match devalang_utils::path::get_devalang_config_path() {
-                Ok(p) => p,
-                Err(_) => {
-                    return None;
-                }
-            };
-            &config_path_buf
-        }
-    };
-
-    if config_path.exists() {
-        let content = fs::read_to_string(config_path).ok()?;
-        toml::from_str(&content).ok()
-    } else {
-        None
-    }
-}
+use crate::config::driver::ProjectConfig;
+use std::fs;
+use std::path::Path;
+
+pub fn load_config(path: Option<&Path>) -> Option<ProjectConfig> {
+    let config_path_buf;
+    let config_path = match path {
+        Some(p) => p,
+        None => {
+            config_path_buf = match devalang_utils::path::get_devalang_config_path() {
+                Ok(p) => p,
+                Err(_) => {
+                    return None;
+                }
+            };
+            &config_path_buf
+        }
+    };
+
+    if config_path.exists() {
+        let content = fs::read_to_string(config_path).ok()?;
+        toml::from_str(&content).ok()
+    } else {
+        None
+    }
+}

package/rust/config/settings.rs

@@ -1,101 +1,101 @@
-use devalang_types::{TelemetrySettings, UserSettings};
-use serde_json::Value as JsonValue;
-use std::io::Write;
-
-pub fn get_home_dir() -> Option<std::path::PathBuf> {
-    dirs::home_dir()
-}
-
-pub fn get_devalang_homedir() -> std::path::PathBuf {
-    if let Some(home_dir) = get_home_dir() {
-        home_dir.join(".devalang")
-    } else {
-        std::path::PathBuf::from("~/.devalang")
-    }
-}
-
-pub fn get_default_user_config() -> UserSettings {
-    UserSettings {
-        session: "".into(),
-        telemetry: TelemetrySettings {
-            uuid: uuid::Uuid::new_v4().to_string(),
-            enabled: false,
-            level: "basic".into(),
-            stats: false,
-        },
-    }
-}
-
-pub fn get_user_config() -> Option<UserSettings> {
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        let file = std::fs::File::open(config_path).ok()?;
-        let settings = serde_json::from_reader(file).ok()?;
-        Some(settings)
-    } else {
-        None
-    }
-}
-
-pub fn write_user_config_file() {
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        let settings = get_user_config().unwrap_or_else(get_default_user_config);
-
-        let config_json = serde_json::to_string(&settings).unwrap();
-
-        if let Err(e) = write_config_atomic(&config_path, &config_json) {
-            println!("Could not write config file: {}", e);
-        }
-    } else {
-        println!("Could not create config file");
-    }
-}
-
-pub fn ensure_user_config_file_exists() {
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        if !config_path.exists() {
-            write_user_config_file();
-        }
-    }
-}
-
-pub fn set_user_config_value(key: &str, value: JsonValue) {
-    let mut settings = get_user_config().unwrap_or_default();
-
-    match (key, &value) {
-        ("telemetry", JsonValue::Bool(b)) => {
-            settings.telemetry.enabled = *b;
-        }
-        ("session", JsonValue::String(s)) => {
-            settings.session = s.clone();
-        }
-        _ => {
-            println!("Unsupported key or value type for '{}': {:?}", key, value);
-        }
-    }
-
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        let config_json = serde_json::to_string(&settings).unwrap();
-        if let Err(e) = write_config_atomic(&config_path, &config_json) {
-            println!("Could not write config file: {}", e);
-        }
-    } else {
-        println!("Could not create config file");
-    }
-}
-
-pub fn write_config_atomic(
-    config_path: &std::path::PathBuf,
-    contents: &str,
-) -> std::io::Result<()> {
-    if let Some(parent) = config_path.parent() {
-        std::fs::create_dir_all(parent)?;
-    }
-
-    let tmp_path = config_path.with_extension("json.tmp");
-    let mut tmp_file = std::fs::File::create(&tmp_path)?;
-    tmp_file.write_all(contents.as_bytes())?;
-    tmp_file.sync_all()?;
-    std::fs::rename(&tmp_path, config_path)?;
-
-    Ok(())
-}
+use devalang_types::{TelemetrySettings, UserSettings};
+use serde_json::Value as JsonValue;
+use std::io::Write;
+
+pub fn get_home_dir() -> Option<std::path::PathBuf> {
+    dirs::home_dir()
+}
+
+pub fn get_devalang_homedir() -> std::path::PathBuf {
+    if let Some(home_dir) = get_home_dir() {
+        home_dir.join(".devalang")
+    } else {
+        std::path::PathBuf::from("~/.devalang")
+    }
+}
+
+pub fn get_default_user_config() -> UserSettings {
+    UserSettings {
+        session: "".into(),
+        telemetry: TelemetrySettings {
+            uuid: uuid::Uuid::new_v4().to_string(),
+            enabled: false,
+            level: "basic".into(),
+            stats: false,
+        },
+    }
+}
+
+pub fn get_user_config() -> Option<UserSettings> {
+    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
+        let file = std::fs::File::open(config_path).ok()?;
+        let settings = serde_json::from_reader(file).ok()?;
+        Some(settings)
+    } else {
+        None
+    }
+}
+
+pub fn write_user_config_file() {
+    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
+        let settings = get_user_config().unwrap_or_else(get_default_user_config);
+
+        let config_json = serde_json::to_string(&settings).unwrap();
+
+        if let Err(e) = write_config_atomic(&config_path, &config_json) {
+            println!("Could not write config file: {}", e);
+        }
+    } else {
+        println!("Could not create config file");
+    }
+}
+
+pub fn ensure_user_config_file_exists() {
+    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
+        if !config_path.exists() {
+            write_user_config_file();
+        }
+    }
+}
+
+pub fn set_user_config_value(key: &str, value: JsonValue) {
+    let mut settings = get_user_config().unwrap_or_default();
+
+    match (key, &value) {
+        ("telemetry", JsonValue::Bool(b)) => {
+            settings.telemetry.enabled = *b;
+        }
+        ("session", JsonValue::String(s)) => {
+            settings.session = s.clone();
+        }
+        _ => {
+            println!("Unsupported key or value type for '{}': {:?}", key, value);
+        }
+    }
+
+    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
+        let config_json = serde_json::to_string(&settings).unwrap();
+        if let Err(e) = write_config_atomic(&config_path, &config_json) {
+            println!("Could not write config file: {}", e);
+        }
+    } else {
+        println!("Could not create config file");
+    }
+}
+
+pub fn write_config_atomic(
+    config_path: &std::path::PathBuf,
+    contents: &str,
+) -> std::io::Result<()> {
+    if let Some(parent) = config_path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+
+    let tmp_path = config_path.with_extension("json.tmp");
+    let mut tmp_file = std::fs::File::create(&tmp_path)?;
+    tmp_file.write_all(contents.as_bytes())?;
+    tmp_file.sync_all()?;
+    std::fs::rename(&tmp_path, config_path)?;
+
+    Ok(())
+}