devalang 0.2.0

Write music with code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

#![cfg(feature = "cli")]

use super::download::download_addon;
use super::metadata::{AddonType, get_addon_from_api, get_addon_publisher_from_api, get_cdn_url};
use anyhow::Result;
use std::fs;

#[derive(serde::Deserialize)]
pub struct AddonVersion {
    pub version: String,
}

/// Retrieves the latest version of an addon from the CDN
async fn fetch_latest_version(addon_type: &AddonType, addon_name: &str) -> Result<AddonVersion> {
    let cdn_url = get_cdn_url();
    let publisher = get_addon_publisher_from_api(addon_name).await?;

    let addon_type_str = addon_type.to_string();

    let url = format!(
        "{}/{}/{}/{}/version",
        cdn_url, addon_type_str, publisher, addon_name
    );

    let response = reqwest::get(&url)
        .await
        .map_err(|e| anyhow::anyhow!("Failed to fetch version: {}", e))?;

    if !response.status().is_success() {
        return Err(anyhow::anyhow!(
            "Failed to fetch version: HTTP {}",
            response.status()
        ));
    }

    let version: AddonVersion = response
        .json()
        .await
        .map_err(|e| anyhow::anyhow!("Failed to parse version: {}", e))?;

    Ok(version)
}

/// Reads the local version of an addon from its TOML file
fn read_local_version(addon_path: &std::path::Path, addon_type: &AddonType) -> String {
    let toml_file = match addon_type {
        AddonType::Bank => "bank.toml",
        AddonType::Plugin => "plugin.toml",
        AddonType::Preset => "preset.toml",
        AddonType::Template => "template.toml",
    };

    let toml_path = addon_path.join(toml_file);

    if !toml_path.exists() {
        return String::new();
    }

    if let Ok(content) = fs::read_to_string(&toml_path) {
        if let Ok(value) = toml::from_str::<toml::Value>(&content) {
            let section = match addon_type {
                AddonType::Bank => "bank",
                AddonType::Plugin => "plugin",
                AddonType::Preset => "preset",
                AddonType::Template => "template",
            };

            if let Some(version) = value
                .get(section)
                .and_then(|s| s.get("version"))
                .and_then(|v| v.as_str())
            {
                return version.to_string();
            }
        }
    }

    String::new()
}

/// Updates an addon
pub async fn update_addon(slug: String) -> Result<()> {
    let addon_metadata = get_addon_from_api(&slug).await?;

    let deva_dir = crate::tools::cli::config::path::ensure_deva_dir()?;

    let publisher_and_name = format!("{}.{}", addon_metadata.publisher, addon_metadata.name);

    // Retrieve the latest version
    let latest = fetch_latest_version(&addon_metadata.addon_type, &addon_metadata.name).await?;

    // Determine the addon path
    let addon_dir = match addon_metadata.addon_type {
        AddonType::Bank => deva_dir.join("banks"),
        AddonType::Plugin => deva_dir.join("plugins"),
        AddonType::Preset => deva_dir.join("presets"),
        AddonType::Template => deva_dir.join("templates"),
    };

    let local_path = addon_dir
        .join(&addon_metadata.publisher)
        .join(&addon_metadata.name);

    let local_version = if local_path.exists() {
        read_local_version(&local_path, &addon_metadata.addon_type)
    } else {
        String::new()
    };

    if local_version.is_empty() {
        return Err(anyhow::anyhow!(
            "Addon '{}' is not installed",
            publisher_and_name
        ));
    }

    if local_version == latest.version {
        // Already up-to-date, no action needed
        return Ok(());
    }

    // Remove the old version
    if local_path.exists() {
        fs::remove_dir_all(&local_path)
            .map_err(|e| anyhow::anyhow!("Failed to remove old addon files: {}", e))?;
    }

    // Download the new version
    download_addon(&publisher_and_name, &addon_metadata).await?;

    // Success is handled by caller in mod.rs
    Ok(())
}