@devaloop/devalang 0.0.1-alpha.14 → 0.0.1-alpha.16

package/rust/core/shared/value.rs

@@ -1,32 +1,35 @@
-use std::collections::HashMap;
-use serde::{ Deserialize, Serialize };
-
-use crate::core::{parser::statement::{Statement, StatementKind}, shared::duration::Duration};
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub enum Value {
-    Boolean(bool),
-    Number(f32),
-    Duration(Duration),
-    Identifier(String),
-    String(String),
-    Array(Vec<Value>),
-    Map(HashMap<String, Value>),
-    Block(Vec<Statement>),
-    Sample(String),
-    Beat(String),
-    Statement(Box<Statement>),
-    StatementKind(Box<StatementKind>),
-    Unknown,
-    Null,
-}
-
-impl Value {
-    pub fn get(&self, key: &str) -> Option<&Value> {
-        if let Value::Map(map) = self {
-            map.get(key)
-        } else {
-            None
-        }
-    }
-}
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    shared::duration::Duration,
+};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Value {
+    Boolean(bool),
+    Number(f32),
+    Duration(Duration),
+    Identifier(String),
+    String(String),
+    Array(Vec<Value>),
+    Map(HashMap<String, Value>),
+    Block(Vec<Statement>),
+    Sample(String),
+    Beat(String),
+    Statement(Box<Statement>),
+    StatementKind(Box<StatementKind>),
+    Unknown,
+    Null,
+}
+
+impl Value {
+    pub fn get(&self, key: &str) -> Option<&Value> {
+        if let Value::Map(map) = self {
+            map.get(key)
+        } else {
+            None
+        }
+    }
+}

package/rust/core/store/function.rs

@@ -1,34 +1,34 @@
-use std::collections::HashMap;
-use crate::core::parser::statement::Statement;
-
-#[derive(Debug, Clone)]
-pub struct FunctionDef {
-    pub name: String,
-    pub parameters: Vec<String>,
-    pub body: Vec<Statement>,
-}
-
-#[derive(Debug, Clone)]
-pub struct FunctionTable {
-    pub functions: HashMap<String, FunctionDef>,
-}
-
-impl FunctionTable {
-    pub fn new() -> Self {
-        FunctionTable {
-            functions: HashMap::new(),
-        }
-    }
-
-    pub fn add_function(&mut self, function: FunctionDef) {
-        self.functions.insert(function.name.clone(), function);
-    }
-
-    pub fn get_function(&self, name: &str) -> Option<&FunctionDef> {
-        self.functions.get(name)
-    }
-
-    pub fn remove_function(&mut self, name: &str) -> Option<FunctionDef> {
-        self.functions.remove(name)
-    }
-}
+use crate::core::parser::statement::Statement;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone)]
+pub struct FunctionDef {
+    pub name: String,
+    pub parameters: Vec<String>,
+    pub body: Vec<Statement>,
+}
+
+#[derive(Debug, Clone)]
+pub struct FunctionTable {
+    pub functions: HashMap<String, FunctionDef>,
+}
+
+impl FunctionTable {
+    pub fn new() -> Self {
+        FunctionTable {
+            functions: HashMap::new(),
+        }
+    }
+
+    pub fn add_function(&mut self, function: FunctionDef) {
+        self.functions.insert(function.name.clone(), function);
+    }
+
+    pub fn get_function(&self, name: &str) -> Option<&FunctionDef> {
+        self.functions.get(name)
+    }
+
+    pub fn remove_function(&mut self, name: &str) -> Option<FunctionDef> {
+        self.functions.remove(name)
+    }
+}

package/rust/core/store/global.rs

@@ -1,38 +1,55 @@
-use std::collections::HashMap;
-use crate::core::{
-    preprocessor::module::Module,
-    store::{ function::FunctionTable, variable::VariableTable },
-};
-
-#[derive(Debug, Clone)]
-pub struct GlobalStore {
-    pub modules: HashMap<String, Module>,
-    pub variables: VariableTable,
-    pub functions: FunctionTable,
-}
-
-impl GlobalStore {
-    pub fn new() -> Self {
-        GlobalStore {
-            modules: HashMap::new(),
-            functions: FunctionTable::new(),
-            variables: VariableTable::new(),
-        }
-    }
-
-    pub fn insert_module(&mut self, path: String, module: Module) {
-        self.modules.insert(path, module);
-    }
-
-    pub fn modules_mut(&mut self) -> &mut HashMap<String, Module> {
-        &mut self.modules
-    }
-
-    pub fn get_module(&self, path: &str) -> Option<&Module> {
-        self.modules.get(path)
-    }
-
-    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
-        self.modules.remove(path)
-    }
-}
+use crate::core::{
+    parser::statement::Statement,
+    plugin::loader::PluginInfo,
+    preprocessor::module::Module,
+    store::{function::FunctionTable, variable::VariableTable},
+};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone)]
+pub struct GlobalStore {
+    pub modules: HashMap<String, Module>,
+    pub variables: VariableTable,
+    pub functions: FunctionTable,
+    pub events: HashMap<String, Vec<Statement>>,
+    pub plugins: HashMap<String, (PluginInfo, Vec<u8>)>,
+}
+
+impl GlobalStore {
+    pub fn new() -> Self {
+        GlobalStore {
+            modules: HashMap::new(),
+            functions: FunctionTable::new(),
+            variables: VariableTable::new(),
+            events: HashMap::new(),
+            plugins: HashMap::new(),
+        }
+    }
+
+    pub fn insert_module(&mut self, path: String, module: Module) {
+        self.modules.insert(path, module);
+    }
+
+    pub fn modules_mut(&mut self) -> &mut HashMap<String, Module> {
+        &mut self.modules
+    }
+
+    pub fn get_module(&self, path: &str) -> Option<&Module> {
+        self.modules.get(path)
+    }
+
+    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
+        self.modules.remove(path)
+    }
+
+    pub fn register_event_handler(&mut self, event: &str, handler: Statement) {
+        self.events
+            .entry(event.to_string())
+            .or_default()
+            .push(handler);
+    }
+
+    pub fn get_event_handlers(&self, event: &str) -> Option<&Vec<Statement>> {
+        self.events.get(event)
+    }
+}

package/rust/core/store/mod.rs

@@ -1,5 +1,5 @@
-pub mod global;
-pub mod export;
-pub mod import;
-pub mod variable;
-pub mod function;
+pub mod export;
+pub mod function;
+pub mod global;
+pub mod import;
+pub mod variable;

package/rust/core/store/variable.rs

@@ -1,34 +1,37 @@
-use std::collections::HashMap;
-
-use crate::core::shared::value::Value;
-
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct VariableTable {
-    pub variables: HashMap<String, Value>,
-    pub parent: Option<Box<VariableTable>>,
-}
-
-impl VariableTable {
-    pub fn new() -> Self {
-        VariableTable {
-            variables: HashMap::new(),
-            parent: None,
-        }
-    }
-
-    pub fn set(&mut self, name: String, value: Value) {
-        self.variables.insert(name, value);
-    }
-
-    pub fn with_parent(parent: VariableTable) -> Self {
-        Self { variables: HashMap::new(), parent: Some(Box::new(parent)) }
-    }
-
-    pub fn get(&self, name: &str) -> Option<&Value> {
-        self.variables.get(name)
-    }
-
-    pub fn remove(&mut self, name: &str) -> Option<Value> {
-        self.variables.remove(name)
-    }
-}
+use std::collections::HashMap;
+
+use crate::core::shared::value::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct VariableTable {
+    pub variables: HashMap<String, Value>,
+    pub parent: Option<Box<VariableTable>>,
+}
+
+impl VariableTable {
+    pub fn new() -> Self {
+        VariableTable {
+            variables: HashMap::new(),
+            parent: None,
+        }
+    }
+
+    pub fn set(&mut self, name: String, value: Value) {
+        self.variables.insert(name, value);
+    }
+
+    pub fn with_parent(parent: VariableTable) -> Self {
+        Self {
+            variables: HashMap::new(),
+            parent: Some(Box::new(parent)),
+        }
+    }
+
+    pub fn get(&self, name: &str) -> Option<&Value> {
+        self.variables.get(name)
+    }
+
+    pub fn remove(&mut self, name: &str) -> Option<Value> {
+        self.variables.remove(name)
+    }
+}

package/rust/core/utils/mod.rs

@@ -1,2 +1,2 @@
-pub mod path;
-pub mod validation;
+pub mod path;
+pub mod validation;

package/rust/core/utils/path.rs

@@ -1,31 +1,37 @@
-use std::path::{ Component, Path, PathBuf };
-
-pub fn find_entry_file(entry: &str) -> Option<String> {
-    let path = Path::new(entry);
-
-    if path.is_file() {
-        return Some(normalize_path(entry));
-    }
-
-    if path.is_dir() {
-        let candidate = path.join("index.deva");
-        if candidate.exists() {
-            return Some(normalize_path(&candidate));
-        }
-    }
-
-    None
-}
-
-pub fn normalize_path<P: AsRef<Path>>(path: P) -> String {
-    let path_buf = PathBuf::from(path.as_ref());
-    path_buf.components().collect::<PathBuf>().to_string_lossy().replace('\\', "/")
-}
-
-pub fn resolve_relative_path(base: &str, import: &str) -> String {
-    let base_path = Path::new(base)
-        .parent()
-        .unwrap_or_else(|| Path::new(""));
-    let full_path = base_path.join(import);
-    full_path.components().collect::<PathBuf>().to_string_lossy().replace("\\", "/")
-}
+use std::path::{Path, PathBuf};
+
+pub fn find_entry_file(entry: &str) -> Option<String> {
+    let path = Path::new(entry);
+
+    if path.is_file() {
+        return Some(normalize_path(entry));
+    }
+
+    if path.is_dir() {
+        let candidate = path.join("index.deva");
+        if candidate.exists() {
+            return Some(normalize_path(&candidate));
+        }
+    }
+
+    None
+}
+
+pub fn normalize_path<P: AsRef<Path>>(path: P) -> String {
+    let path_buf = PathBuf::from(path.as_ref());
+    path_buf
+        .components()
+        .collect::<PathBuf>()
+        .to_string_lossy()
+        .replace('\\', "/")
+}
+
+pub fn resolve_relative_path(base: &str, import: &str) -> String {
+    let base_path = Path::new(base).parent().unwrap_or_else(|| Path::new(""));
+    let full_path = base_path.join(import);
+    full_path
+        .components()
+        .collect::<PathBuf>()
+        .to_string_lossy()
+        .replace("\\", "/")
+}

package/rust/core/utils/validation.rs

@@ -1,37 +1,35 @@
-use crate::core::{ preprocessor::module::Module, shared::value::Value, store::global::GlobalStore };
-
-// NOTE: Deprecated functions, kept for reference
-
-// pub fn is_valid_entity(entity: &str, module: &Module, global_store: &GlobalStore) -> bool {
-//     let built_ins = ["kick", "snare", "hat", "clap"];
-
-//     if built_ins.contains(&entity) {
-//         return true;
-//     }
-
-//     if let Some(val) = module.variable_table.get(entity) {
-//         match val {
-//             Value::Sample(_) => true,
-//             _ => false,
-//         }
-//     } else {
-//         false
-//     }
-// }
-
-// pub fn is_valid_identifier(ident: &str, module: &Module) -> bool {
-//     let built_ins = ["auto"];
-
-//     if built_ins.contains(&ident) {
-//         return true;
-//     }
-
-//     if let Some(val) = module.variable_table.get(ident) {
-//         match val {
-//             Value::Identifier(_) => true,
-//             _ => false,
-//         }
-//     } else {
-//         false
-//     }
-// }
+// NOTE: Deprecated functions, kept for reference
+
+// pub fn is_valid_entity(entity: &str, module: &Module, global_store: &GlobalStore) -> bool {
+//     let built_ins = ["kick", "snare", "hat", "clap"];
+
+//     if built_ins.contains(&entity) {
+//         return true;
+//     }
+
+//     if let Some(val) = module.variable_table.get(entity) {
+//         match val {
+//             Value::Sample(_) => true,
+//             _ => false,
+//         }
+//     } else {
+//         false
+//     }
+// }
+
+// pub fn is_valid_identifier(ident: &str, module: &Module) -> bool {
+//     let built_ins = ["auto"];
+
+//     if built_ins.contains(&ident) {
+//         return true;
+//     }
+
+//     if let Some(val) = module.variable_table.get(ident) {
+//         match val {
+//             Value::Identifier(_) => true,
+//             _ => false,
+//         }
+//     } else {
+//         false
+//     }
+// }

package/rust/installer/addon.rs

@@ -1,80 +1,84 @@
-use std::path::Path;
-use crate::{
-    common::{ api::get_api_url },
-    installer::{ bank::install_bank, plugin::install_plugin },
-};
-use dirs::home_dir;
-
-#[derive(Debug, Clone)]
-pub enum AddonType {
-    Bank,
-    Plugin,
-    Preset,
-}
-
-pub async fn install_addon(
-    addon_type: AddonType,
-    name: &str,
-    target_dir: &Path
-) -> Result<(), String> {
-    match addon_type {
-        AddonType::Bank => install_bank(name, target_dir).await,
-        AddonType::Plugin => install_plugin(name, target_dir).await,
-        AddonType::Preset => Err("Preset installation not implemented".into()),
-    }
-}
-
-pub async fn ask_api_for_signed_url(addon_type: AddonType, slug: &str) -> Result<String, String> {
-    let api_url = get_api_url();
-
-    let mut stored_token_path = home_dir().unwrap();
-    stored_token_path.push(".devalang");
-    stored_token_path.push("session_token.json");
-
-    let stored_token = std::fs::read_to_string(&stored_token_path).unwrap_or_default();
-
-    let request_url = format!(
-        "{}/v1/assets/url?type={}&slug={}&token={}",
-        api_url,
-        match addon_type {
-            AddonType::Bank => "bank",
-            AddonType::Plugin => "plugin",
-            AddonType::Preset => "preset",
-        },
-        slug,
-        stored_token
-    );
-
-    let mut headers = reqwest::header::HeaderMap::new();
-
-    headers.insert("Authorization", format!("Bearer {}", stored_token).parse().unwrap());
-
-    let client: reqwest::Client = reqwest::Client
-        ::builder()
-        .default_headers(headers)
-        .build()
-        .map_err(|_| "Failed to build HTTP client".to_string())?;
-
-    let req = client
-        .get(&request_url)
-        .send().await
-        .map_err(|_| "Failed to receive response".to_string())?;
-
-    let response_body: serde_json::Value = req
-        .json().await
-        .map_err(|_| "Failed to read response body".to_string())?;
-
-    let signed_url: String = serde_json
-        ::from_value(
-            response_body
-                .get("payload")
-                .cloned()
-                .unwrap_or_default()
-                .get("url")
-                .cloned()
-                .unwrap_or_default()
-        )
-        .map_err(|_| "Failed to parse response body".to_string())?;
-
-    Ok(signed_url)
-}
+use crate::{
+    common::api::get_api_url,
+    config::settings::get_user_config,
+    installer::{bank::install_bank, plugin::install_plugin},
+};
+use std::path::Path;
+
+#[derive(Debug, Clone)]
+pub enum AddonType {
+    Bank,
+    Plugin,
+    Preset,
+}
+
+pub async fn install_addon(
+    addon_type: AddonType,
+    name: &str,
+    target_dir: &Path,
+) -> Result<(), String> {
+    match addon_type {
+        AddonType::Bank => install_bank(name, target_dir).await,
+        AddonType::Plugin => install_plugin(name, target_dir).await,
+        AddonType::Preset => Err("Preset installation not implemented".into()),
+    }
+}
+
+pub async fn ask_api_for_signed_url(addon_type: AddonType, slug: &str) -> Result<String, String> {
+    let api_url = get_api_url();
+
+    let user_config = get_user_config();
+    if user_config.is_none() {
+        return Err("User is not logged in".into());
+    }
+
+    let stored_token = user_config.unwrap().session.clone();
+
+    let request_url = format!(
+        "{}/v1/assets/url?type={}&slug={}&token={}",
+        api_url,
+        match addon_type {
+            AddonType::Bank => "bank",
+            AddonType::Plugin => "plugin",
+            AddonType::Preset => "preset",
+        },
+        slug,
+        stored_token
+    );
+
+    let mut headers = reqwest::header::HeaderMap::new();
+
+    headers.insert(
+        "Authorization",
+        format!("Bearer {}", stored_token).parse().unwrap(),
+    );
+
+    let client: reqwest::Client = reqwest::Client::builder()
+        .default_headers(headers)
+        .build()
+        .map_err(|_| "Failed to build HTTP client".to_string())?;
+
+    let req = client
+        .get(&request_url)
+        .send()
+        .await
+        .map_err(|_| "Failed to receive response".to_string())?;
+
+    let response_body: serde_json::Value = req
+        .json()
+        .await
+        .map_err(|_| "Failed to read response body".to_string())?;
+
+    let signed_url: String = serde_json::from_value(
+        response_body
+            .get("payload")
+            .cloned()
+            .unwrap_or_default()
+            .get("url")
+            .cloned()
+            .unwrap_or_default(),
+    )
+    .map_err(|_| "Failed to parse response body".to_string())?;
+
+    Ok(signed_url)
+}