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

package/rust/cli/telemetry.rs

@@ -0,0 +1,19 @@
+use crate::config::settings::set_user_config_bool;
+
+#[cfg(feature = "cli")]
+pub async fn handle_telemetry_enable_command() -> Result<(), String> {
+    set_user_config_bool("telemetry", true);
+
+    println!("Telemetry has been enabled.");
+
+    Ok(())
+}
+
+#[cfg(feature = "cli")]
+pub async fn handle_telemetry_disable_command() -> Result<(), String> {
+    set_user_config_bool("telemetry", false);
+
+    println!("Telemetry has been disabled.");
+
+    Ok(())
+}

package/rust/cli/template.rs

@@ -1,57 +1,69 @@
-use include_dir::{ include_dir, Dir, DirEntry };
-use crate::utils::file::format_file_size;
-
-static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
-
-#[cfg(feature = "cli")]
-pub fn handle_template_list_command() {
-    let available_templates = get_available_templates();
-
-    println!("📦 Available templates ({}) :\n", available_templates.len());
-
-    for dir in available_templates {
-        println!("• {}", dir);
-    }
-
-    println!("\nUsage : devalang init --name <project-name> --template <template-name>");
-}
-
-#[cfg(feature = "cli")]
-pub fn handle_template_info_command(name: String) {
-    let template_dir = TEMPLATES_DIR.get_dir(name.clone()).unwrap_or_else(|| {
-        println!("❌ The template '{}' is not found.", name);
-
-        std::process::exit(1);
-    });
-
-    let mut file_count = 0;
-    let mut dir_count = 0;
-    let mut total_size: u64 = 0;
-
-    fn walk(dir: &Dir, file_count: &mut u32, dir_count: &mut u32, total_size: &mut u64) {
-        for entry in dir.entries() {
-            match entry {
-                DirEntry::File(file) => {
-                    *file_count += 1;
-                    *total_size += file.contents().len() as u64;
-                }
-                DirEntry::Dir(subdir) => {
-                    *dir_count += 1;
-                    walk(subdir, file_count, dir_count, total_size);
-                }
-            }
-        }
-    }
-
-    walk(template_dir, &mut file_count, &mut dir_count, &mut total_size);
-
-    println!("📦 Template : {}", name);
-    println!("📂 Content  : {file_count} file(s), {dir_count} folder(s)");
-    println!("💾 Size     : {}", format_file_size(total_size));
-}
-
-pub fn get_available_templates() -> Vec<String> {
-    TEMPLATES_DIR.dirs()
-        .map(|dir| dir.path().file_name().unwrap().to_string_lossy().to_string())
-        .collect()
-}
+use crate::utils::file::format_file_size;
+use include_dir::{Dir, DirEntry, include_dir};
+
+static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
+
+#[cfg(feature = "cli")]
+pub fn handle_template_list_command() {
+    let available_templates = get_available_templates();
+
+    println!("📦 Available templates ({}) :\n", available_templates.len());
+
+    for dir in available_templates {
+        println!("• {}", dir);
+    }
+
+    println!("\nUsage : devalang init --name <project-name> --template <template-name>");
+}
+
+#[cfg(feature = "cli")]
+pub fn handle_template_info_command(name: String) {
+    let template_dir = TEMPLATES_DIR.get_dir(name.clone()).unwrap_or_else(|| {
+        println!("❌ The template '{}' is not found.", name);
+
+        std::process::exit(1);
+    });
+
+    let mut file_count = 0;
+    let mut dir_count = 0;
+    let mut total_size: u64 = 0;
+
+    fn walk(dir: &Dir, file_count: &mut u32, dir_count: &mut u32, total_size: &mut u64) {
+        for entry in dir.entries() {
+            match entry {
+                DirEntry::File(file) => {
+                    *file_count += 1;
+                    *total_size += file.contents().len() as u64;
+                }
+                DirEntry::Dir(subdir) => {
+                    *dir_count += 1;
+                    walk(subdir, file_count, dir_count, total_size);
+                }
+            }
+        }
+    }
+
+    walk(
+        template_dir,
+        &mut file_count,
+        &mut dir_count,
+        &mut total_size,
+    );
+
+    println!("📦 Template : {}", name);
+    println!("📂 Content  : {file_count} file(s), {dir_count} folder(s)");
+    println!("💾 Size     : {}", format_file_size(total_size));
+}
+
+pub fn get_available_templates() -> Vec<String> {
+    TEMPLATES_DIR
+        .dirs()
+        .map(|dir| {
+            dir.path()
+                .file_name()
+                .unwrap()
+                .to_string_lossy()
+                .to_string()
+        })
+        .collect()
+}

package/rust/cli/update.rs

@@ -1,4 +1,6 @@
-pub async fn handle_update_command(only: Option<String>) -> Result<(), Box<dyn std::error::Error>> {
-    println!("Updates are not yet implemented. This is a placeholder function.");
-    Ok(())
-}
+pub async fn handle_update_command(
+    _only: Option<String>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    println!("Updates are not yet implemented. This is a placeholder function.");
+    Ok(())
+}

package/rust/common/api.rs

@@ -1,8 +1,5 @@
-pub fn get_api_url() -> String {
-    let api_url = std::env
-        ::var("API_URL")
-        .unwrap_or_else(|_| "https://api.devalang.com".to_string());
-        // .unwrap_or_else(|_| "http://127.0.0.1:8989".to_string());
-
-    api_url
-}
+pub fn get_api_url() -> String {
+    let api_url = "https://api.devalang.com";
+    // let api_url = "http://127.0.0.1:8989";
+    api_url.to_string()
+}

package/rust/common/cdn.rs

@@ -1,8 +1,5 @@
 pub fn get_cdn_url() -> String {
-    let cdn_url = std::env
-        ::var("CDN_URL")
-        .unwrap_or_else(|_| "https://cdn.devalang.com".to_string());
-        // .unwrap_or_else(|_| "http://127.0.0.1:8888".to_string());
-
-    cdn_url
+    let cdn_url = "https://cdn.devalang.com";
+    // let cdn_url = "http://127.0.0.1:8888";
+    cdn_url.to_string()
 }

package/rust/common/mod.rs

@@ -1,3 +1,3 @@
-pub mod cdn;
-pub mod api;
-pub mod sso;
+pub mod api;
+pub mod cdn;
+pub mod sso;

package/rust/common/sso.rs

@@ -1,8 +1,5 @@
 pub fn get_sso_url() -> String {
-    let sso_url = std::env
-        ::var("SSO_URL")
-        .unwrap_or_else(|_| "https://sso.devalang.com".to_string());
-        // .unwrap_or_else(|_| "http://localhost:5174".to_string());
-
-    sso_url
+    let sso_url = "https://sso.devalang.com";
+    // let sso_url = "http://localhost:5174";
+    sso_url.to_string()
 }

package/rust/config/driver.rs

@@ -1,94 +1,118 @@
-use std::collections::HashMap;
-
-use serde::{ Deserialize, Serialize };
-
-#[derive(Debug, Deserialize, Clone, Serialize)]
-pub struct Config {
-    pub defaults: ConfigDefaults,
-    pub banks: Option<Vec<BankEntry>>,
-    pub plugins: Option<Vec<PluginEntry>>,
-}
-
-#[derive(Debug, Deserialize, Clone, Serialize)]
-pub struct ConfigDefaults {
-    pub entry: Option<String>,
-    pub output: Option<String>,
-    pub watch: Option<bool>,
-    pub repeat: Option<bool>,
-}
-
-#[derive(Debug, Deserialize, Clone, Serialize)]
-pub struct BankMetadata {
-    pub bank: HashMap<String, String>,
-    pub triggers: Option<Vec<HashMap<String, String>>>,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-pub struct BankEntry {
-    pub path: String,
-    pub version: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-pub struct PluginEntry {
-    pub path: String,
-    pub version: String,
-    pub author: String,
-    pub access: String,
-}
-
-impl Config {
-    pub fn new() -> Self {
-        Config {
-            defaults: ConfigDefaults {
-                entry: None,
-                output: None,
-                watch: None,
-                repeat: None,
-            },
-            banks: Some(Vec::new()),
-            plugins: Some(Vec::new()),
-        }
-    }
-
-    pub fn with_defaults(
-        entry: Option<String>,
-        output: Option<String>,
-        watch: Option<bool>,
-        repeat: Option<bool>
-    ) -> Self {
-        Config {
-            defaults: ConfigDefaults {
-                entry,
-                output,
-                watch,
-                repeat,
-            },
-            banks: Some(Vec::new()),
-            plugins: Some(Vec::new()),
-        }
-    }
-
-    pub fn from_string(config_string: &str) -> Result<(Self, String), String> {
-        let config: Config = 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))
-    }
-
-    pub fn write(&self, new_config: &Config) -> Result<(), String> {
-        let config_path = ".devalang";
-
-        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, e))?;
-
-        Ok(())
-    }
-}
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct ProjectConfig {
+    pub defaults: ProjectConfigDefaults,
+    pub banks: Option<Vec<ProjectConfigBankEntry>>,
+    pub plugins: Option<Vec<PluginEntry>>,
+}
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct ProjectConfigDefaults {
+    pub entry: Option<String>,
+    pub output: Option<String>,
+    pub watch: Option<bool>,
+    pub repeat: Option<bool>,
+    pub debug: Option<bool>,
+    pub compress: Option<bool>,
+}
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct ProjectConfigBankMetadata {
+    pub bank: HashMap<String, String>,
+    pub triggers: Option<Vec<HashMap<String, String>>>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub struct ProjectConfigBankEntry {
+    pub path: String,
+    pub version: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub struct PluginEntry {
+    pub path: String,
+    pub version: String,
+    pub author: String,
+    pub access: String,
+}
+
+impl ProjectConfig {
+    pub fn new() -> Self {
+        ProjectConfig {
+            defaults: ProjectConfigDefaults {
+                entry: None,
+                output: None,
+                watch: None,
+                repeat: None,
+                debug: None,
+                compress: None,
+            },
+            banks: Some(Vec::new()),
+            plugins: Some(Vec::new()),
+        }
+    }
+
+    pub fn with_defaults(
+        entry: Option<String>,
+        output: Option<String>,
+        watch: Option<bool>,
+        repeat: Option<bool>,
+        debug: Option<bool>,
+        compress: Option<bool>,
+    ) -> Self {
+        ProjectConfig {
+            defaults: ProjectConfigDefaults {
+                entry,
+                output,
+                watch,
+                repeat,
+                debug,
+                compress,
+            },
+            banks: Some(Vec::new()),
+            plugins: Some(Vec::new()),
+        }
+    }
+
+    pub fn get() -> Result<ProjectConfig, String> {
+        let root = std::env::current_dir().unwrap();
+        let config_path = root.join(".devalang");
+
+        if config_path.try_exists().is_err() {
+            return Err(format!(
+                "Config file not found at path: {}",
+                config_path.display()
+            ));
+        }
+
+        let config_content = std::fs::read_to_string(&config_path)
+            .map_err(|e| format!("Failed to read config file: {}", e))?;
+
+        let config: ProjectConfig = toml::from_str(&config_content)
+            .map_err(|e| format!("Failed to parse config file: {}", e))?;
+
+        Ok(config)
+    }
+
+    pub fn from_string(config_string: &str) -> Result<(Self, String), String> {
+        let config: ProjectConfig = 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))
+    }
+
+    pub fn write(&self, new_config: &ProjectConfig) -> Result<(), String> {
+        let config_path = ".devalang";
+
+        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, e))?;
+
+        Ok(())
+    }
+}