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

package/rust/cli/discover/config.rs

@@ -1,111 +1,111 @@
-use devalang_core::config::driver::ProjectConfigExt;
-use devalang_types::{AddonWithMetadata, ProjectConfigBankEntry, ProjectConfigPluginEntry};
-use devalang_utils::path as path_utils;
-
-pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(), String> {
-    let config_path = path_utils::get_devalang_config_path()?;
-    let mut config = crate::config::ops::load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    for addon in addons {
-        let addon_path_as_devalang_protocol = format!(
-            "devalang://{}/{}.{}",
-            addon.addon_type, addon.metadata.author, addon.metadata.name
-        );
-
-        match addon.addon_type.as_str() {
-            "bank" => {
-                if config.banks.is_none() {
-                    config.banks = Some(Vec::new());
-                }
-
-                let banks = config.banks.as_mut().unwrap();
-
-                let exists = banks
-                    .iter()
-                    .any(|b| b.path == addon_path_as_devalang_protocol);
-                if exists {
-                    println!("Bank '{}' already in config", addon.name);
-                    continue;
-                }
-
-                banks.push(ProjectConfigBankEntry {
-                    path: addon_path_as_devalang_protocol,
-                    version: Some(addon.metadata.version.clone()),
-                });
-            }
-
-            "plugin" => {
-                if config.plugins.is_none() {
-                    config.plugins = Some(Vec::new());
-                }
-
-                let plugins = config.plugins.as_mut().unwrap();
-
-                let exists = plugins
-                    .iter()
-                    .any(|p| p.path == addon_path_as_devalang_protocol);
-                if exists {
-                    println!("Plugin '{}' already in config", addon.name);
-                    continue;
-                }
-
-                plugins.push(ProjectConfigPluginEntry {
-                    path: addon_path_as_devalang_protocol,
-                    version: Some(addon.metadata.version.clone()),
-                });
-            }
-
-            // "preset" => {
-            //     if config.presets.is_none() {
-            //         config.presets = Some(Vec::new());
-            //     }
-
-            //     let presets = config.presets.as_mut().unwrap();
-
-            //     let exists = presets.iter().any(|p| p.path == addon_path_as_deva_protocol);
-            //     if exists {
-            //         println!("Preset '{}' already in config", addon.name);
-            //         continue;
-            //     }
-
-            //     presets.push(ProjectConfigPresetEntry {
-            //         path: addon_path_as_deva_protocol,
-            //         version: Some(addon.metadata.version.clone()),
-            //     });
-            // }
-
-            // "template" => {
-            //     if config.templates.is_none() {
-            //         config.templates = Some(Vec::new());
-            //     }
-
-            //     let templates = config.templates.as_mut().unwrap();
-
-            //     let exists = templates.iter().any(|t| t.path == addon_path_as_deva_protocol);
-            //     if exists {
-            //         println!("Template '{}' already in config", addon.name);
-            //         continue;
-            //     }
-
-            //     templates.push(ProjectConfigTemplateEntry {
-            //         path: addon_path_as_deva_protocol,
-            //         version: Some(addon.metadata.version.clone()),
-            //     });
-            // }
-            _ => {
-                println!(
-                    "Unknown addon type '{}' for addon '{}'",
-                    addon.addon_type, addon.name
-                );
-            }
-        }
-    }
-
-    // Update config with new addons
-    if let Err(e) = config.write_config(&config) {
-        return Err(format!("Failed to write config: {}", e));
-    }
-
-    Ok(())
-}
+use devalang_core::config::driver::ProjectConfigExt;
+use devalang_types::{AddonWithMetadata, ProjectConfigBankEntry, ProjectConfigPluginEntry};
+use devalang_utils::path as path_utils;
+
+pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(), String> {
+    let config_path = path_utils::get_devalang_config_path()?;
+    let mut config = crate::config::ops::load_config(Some(&config_path))
+        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
+
+    for addon in addons {
+        let addon_path_as_devalang_protocol = format!(
+            "devalang://{}/{}.{}",
+            addon.addon_type, addon.metadata.author, addon.metadata.name
+        );
+
+        match addon.addon_type.as_str() {
+            "bank" => {
+                if config.banks.is_none() {
+                    config.banks = Some(Vec::new());
+                }
+
+                let banks = config.banks.as_mut().unwrap();
+
+                let exists = banks
+                    .iter()
+                    .any(|b| b.path == addon_path_as_devalang_protocol);
+                if exists {
+                    println!("Bank '{}' already in config", addon.name);
+                    continue;
+                }
+
+                banks.push(ProjectConfigBankEntry {
+                    path: addon_path_as_devalang_protocol,
+                    version: Some(addon.metadata.version.clone()),
+                });
+            }
+
+            "plugin" => {
+                if config.plugins.is_none() {
+                    config.plugins = Some(Vec::new());
+                }
+
+                let plugins = config.plugins.as_mut().unwrap();
+
+                let exists = plugins
+                    .iter()
+                    .any(|p| p.path == addon_path_as_devalang_protocol);
+                if exists {
+                    println!("Plugin '{}' already in config", addon.name);
+                    continue;
+                }
+
+                plugins.push(ProjectConfigPluginEntry {
+                    path: addon_path_as_devalang_protocol,
+                    version: Some(addon.metadata.version.clone()),
+                });
+            }
+
+            // "preset" => {
+            //     if config.presets.is_none() {
+            //         config.presets = Some(Vec::new());
+            //     }
+
+            //     let presets = config.presets.as_mut().unwrap();
+
+            //     let exists = presets.iter().any(|p| p.path == addon_path_as_deva_protocol);
+            //     if exists {
+            //         println!("Preset '{}' already in config", addon.name);
+            //         continue;
+            //     }
+
+            //     presets.push(ProjectConfigPresetEntry {
+            //         path: addon_path_as_deva_protocol,
+            //         version: Some(addon.metadata.version.clone()),
+            //     });
+            // }
+
+            // "template" => {
+            //     if config.templates.is_none() {
+            //         config.templates = Some(Vec::new());
+            //     }
+
+            //     let templates = config.templates.as_mut().unwrap();
+
+            //     let exists = templates.iter().any(|t| t.path == addon_path_as_deva_protocol);
+            //     if exists {
+            //         println!("Template '{}' already in config", addon.name);
+            //         continue;
+            //     }
+
+            //     templates.push(ProjectConfigTemplateEntry {
+            //         path: addon_path_as_deva_protocol,
+            //         version: Some(addon.metadata.version.clone()),
+            //     });
+            // }
+            _ => {
+                println!(
+                    "Unknown addon type '{}' for addon '{}'",
+                    addon.addon_type, addon.name
+                );
+            }
+        }
+    }
+
+    // Update config with new addons
+    if let Err(e) = config.write_config(&config) {
+        return Err(format!("Failed to write config: {}", e));
+    }
+
+    Ok(())
+}

package/rust/cli/discover/fs.rs

@@ -1,19 +1,19 @@
-use std::{fs, io, path::Path};
-
-pub fn copy_dir_all(src: &Path, dst: &Path) -> Result<(), io::Error> {
-    if !dst.exists() {
-        fs::create_dir_all(dst)?;
-    }
-    for entry in fs::read_dir(src)? {
-        let entry = entry?;
-        let ty = entry.file_type()?;
-        let from = entry.path();
-        let to = dst.join(entry.file_name());
-        if ty.is_dir() {
-            copy_dir_all(&from, &to)?;
-        } else {
-            fs::copy(&from, &to)?;
-        }
-    }
-    Ok(())
-}
+use std::{fs, io, path::Path};
+
+pub fn copy_dir_all(src: &Path, dst: &Path) -> Result<(), io::Error> {
+    if !dst.exists() {
+        fs::create_dir_all(dst)?;
+    }
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        let from = entry.path();
+        let to = dst.join(entry.file_name());
+        if ty.is_dir() {
+            copy_dir_all(&from, &to)?;
+        } else {
+            fs::copy(&from, &to)?;
+        }
+    }
+    Ok(())
+}

package/rust/cli/discover/install.rs

@@ -1,103 +1,103 @@
-use devalang_types::{AddonMetadata, AddonWithMetadata, DiscoveredAddon};
-use devalang_utils::path as path_utils;
-
-pub async fn install_selected_addons(
-    addons: Vec<DiscoveredAddon>,
-) -> Result<Vec<AddonWithMetadata>, String> {
-    let mut addons_enriched = Vec::new();
-
-    let tmp_dir = path_utils::ensure_deva_dir()?.join("tmp");
-
-    for addon in addons {
-        std::fs::create_dir_all(tmp_dir.join(&addon.name))
-            .map_err(|e| format!("Failed to create directory for addon {}: {}", addon.name, e))?;
-
-        let addon_path = tmp_dir.join(&addon.name);
-        devalang_utils::file::extract_zip_safely(&addon.path, &addon_path)
-            .map_err(|e| format!("Failed to extract addon {}: {}", addon.name, e))?;
-
-        let base = path_utils::ensure_deva_dir()?;
-        let target_addon_dir = match addon.addon_type.as_str() {
-            "bank" => base.join("banks"),
-            "plugin" => base.join("plugins"),
-            "preset" => base.join("presets"),
-            "template" => base.join("templates"),
-            _ => {
-                return Err(format!("Unknown addon type for addon {}", addon.name));
-            }
-        };
-
-        std::fs::create_dir_all(&target_addon_dir).map_err(|e| {
-            format!(
-                "Failed to create target directory for addon {}: {}",
-                addon.name, e
-            )
-        })?;
-
-        let target_addon_path_dir = target_addon_dir.join(&addon.name);
-        if target_addon_path_dir.exists() {
-            println!(
-                "Target addon directory {} already exists",
-                target_addon_path_dir.display()
-            );
-            continue;
-        }
-
-        if let Err(e) = std::fs::rename(&addon_path, &target_addon_path_dir) {
-            crate::cli::discover::fs::copy_dir_all(&addon_path, &target_addon_path_dir).map_err(
-                |err| {
-                    format!(
-                        "Failed to move addon {}: {} (rename error: {})",
-                        addon.name, err, e
-                    )
-                },
-            )?;
-            let _ = std::fs::remove_dir_all(&addon_path);
-        }
-
-        let addon_metadata_filename = match addon.addon_type.as_str() {
-            "bank" => "bank.toml",
-            "plugin" => "plugin.toml",
-            "preset" => "preset.toml",
-            "template" => "template.toml",
-            _ => {
-                return Err(format!("Unknown addon type for addon {}", addon.name));
-            }
-        };
-
-        let addon_metadata_path = target_addon_path_dir.join(addon_metadata_filename);
-        let addon_metadata_content = std::fs::read_to_string(&addon_metadata_path)
-            .map_err(|e| format!("Failed to read metadata for addon {}: {}", addon.name, e))?;
-
-        let parsed_meta = crate::cli::discover::metadata::parse_metadata_file(
-            &addon.addon_type,
-            &addon_metadata_content,
-        )
-        .unwrap_or(AddonMetadata {
-            name: addon.name.clone(),
-            author: "unknown".to_string(),
-            version: "".to_string(),
-            description: "".to_string(),
-            access: "".to_string(),
-        });
-
-        addons_enriched.push(AddonWithMetadata {
-            name: addon.name.clone(),
-            path: addon.path.clone().to_string_lossy().to_string(),
-            addon_type: addon.addon_type.clone(),
-            metadata: parsed_meta,
-        });
-
-        if let Err(e) = std::fs::remove_file(&addon.path) {
-            eprintln!(
-                "Failed to remove zipped file for addon {}: {}",
-                addon.name, e
-            );
-        }
-    }
-
-    // Best-effort cleanup of temporary extraction directory
-    let _ = std::fs::remove_dir_all(&tmp_dir);
-
-    Ok(addons_enriched)
-}
+use devalang_types::{AddonMetadata, AddonWithMetadata, DiscoveredAddon};
+use devalang_utils::path as path_utils;
+
+pub async fn install_selected_addons(
+    addons: Vec<DiscoveredAddon>,
+) -> Result<Vec<AddonWithMetadata>, String> {
+    let mut addons_enriched = Vec::new();
+
+    let tmp_dir = path_utils::ensure_deva_dir()?.join("tmp");
+
+    for addon in addons {
+        std::fs::create_dir_all(tmp_dir.join(&addon.name))
+            .map_err(|e| format!("Failed to create directory for addon {}: {}", addon.name, e))?;
+
+        let addon_path = tmp_dir.join(&addon.name);
+        devalang_utils::file::extract_zip_safely(&addon.path, &addon_path)
+            .map_err(|e| format!("Failed to extract addon {}: {}", addon.name, e))?;
+
+        let base = path_utils::ensure_deva_dir()?;
+        let target_addon_dir = match addon.addon_type.as_str() {
+            "bank" => base.join("banks"),
+            "plugin" => base.join("plugins"),
+            "preset" => base.join("presets"),
+            "template" => base.join("templates"),
+            _ => {
+                return Err(format!("Unknown addon type for addon {}", addon.name));
+            }
+        };
+
+        std::fs::create_dir_all(&target_addon_dir).map_err(|e| {
+            format!(
+                "Failed to create target directory for addon {}: {}",
+                addon.name, e
+            )
+        })?;
+
+        let target_addon_path_dir = target_addon_dir.join(&addon.name);
+        if target_addon_path_dir.exists() {
+            println!(
+                "Target addon directory {} already exists",
+                target_addon_path_dir.display()
+            );
+            continue;
+        }
+
+        if let Err(e) = std::fs::rename(&addon_path, &target_addon_path_dir) {
+            crate::cli::discover::fs::copy_dir_all(&addon_path, &target_addon_path_dir).map_err(
+                |err| {
+                    format!(
+                        "Failed to move addon {}: {} (rename error: {})",
+                        addon.name, err, e
+                    )
+                },
+            )?;
+            let _ = std::fs::remove_dir_all(&addon_path);
+        }
+
+        let addon_metadata_filename = match addon.addon_type.as_str() {
+            "bank" => "bank.toml",
+            "plugin" => "plugin.toml",
+            "preset" => "preset.toml",
+            "template" => "template.toml",
+            _ => {
+                return Err(format!("Unknown addon type for addon {}", addon.name));
+            }
+        };
+
+        let addon_metadata_path = target_addon_path_dir.join(addon_metadata_filename);
+        let addon_metadata_content = std::fs::read_to_string(&addon_metadata_path)
+            .map_err(|e| format!("Failed to read metadata for addon {}: {}", addon.name, e))?;
+
+        let parsed_meta = crate::cli::discover::metadata::parse_metadata_file(
+            &addon.addon_type,
+            &addon_metadata_content,
+        )
+        .unwrap_or(AddonMetadata {
+            name: addon.name.clone(),
+            author: "unknown".to_string(),
+            version: "".to_string(),
+            description: "".to_string(),
+            access: "".to_string(),
+        });
+
+        addons_enriched.push(AddonWithMetadata {
+            name: addon.name.clone(),
+            path: addon.path.clone().to_string_lossy().to_string(),
+            addon_type: addon.addon_type.clone(),
+            metadata: parsed_meta,
+        });
+
+        if let Err(e) = std::fs::remove_file(&addon.path) {
+            eprintln!(
+                "Failed to remove zipped file for addon {}: {}",
+                addon.name, e
+            );
+        }
+    }
+
+    // Best-effort cleanup of temporary extraction directory
+    let _ = std::fs::remove_dir_all(&tmp_dir);
+
+    Ok(addons_enriched)
+}

package/rust/cli/discover/metadata.rs

@@ -1,48 +1,48 @@
-use devalang_types::AddonMetadata;
-use toml::Value;
-
-pub fn parse_metadata_file(addon_type: &str, metadata_content: &str) -> Option<AddonMetadata> {
-    let parsed = metadata_content.parse::<Value>().ok()?;
-
-    let table = (match addon_type {
-        "bank" => parsed.get("bank"),
-        "plugin" => parsed.get("plugin"),
-        "preset" => parsed.get("preset"),
-        "template" => parsed.get("template"),
-        _ => None,
-    })?;
-
-    let name = table
-        .get("name")
-        .and_then(|v| v.as_str())
-        .unwrap_or("")
-        .to_string();
-    let version = table
-        .get("version")
-        .and_then(|v| v.as_str())
-        .unwrap_or("")
-        .to_string();
-    let description = table
-        .get("description")
-        .and_then(|v| v.as_str())
-        .unwrap_or("")
-        .to_string();
-    let author = table
-        .get("author")
-        .and_then(|v| v.as_str())
-        .unwrap_or("unknown")
-        .to_string();
-    let access = table
-        .get("access")
-        .and_then(|v| v.as_str())
-        .unwrap_or("")
-        .to_string();
-
-    Some(AddonMetadata {
-        name,
-        author,
-        version,
-        description,
-        access,
-    })
-}
+use devalang_types::AddonMetadata;
+use toml::Value;
+
+pub fn parse_metadata_file(addon_type: &str, metadata_content: &str) -> Option<AddonMetadata> {
+    let parsed = metadata_content.parse::<Value>().ok()?;
+
+    let table = (match addon_type {
+        "bank" => parsed.get("bank"),
+        "plugin" => parsed.get("plugin"),
+        "preset" => parsed.get("preset"),
+        "template" => parsed.get("template"),
+        _ => None,
+    })?;
+
+    let name = table
+        .get("name")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let version = table
+        .get("version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let description = table
+        .get("description")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let author = table
+        .get("author")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+    let access = table
+        .get("access")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    Some(AddonMetadata {
+        name,
+        author,
+        version,
+        description,
+        access,
+    })
+}

package/rust/cli/discover/mod.rs

@@ -1,5 +1,5 @@
-pub mod commands;
-pub mod config;
-pub mod fs;
-pub mod install;
-pub mod metadata;
+pub mod commands;
+pub mod config;
+pub mod fs;
+pub mod install;
+pub mod metadata;