@devaloop/devalang 0.0.1-alpha.2 → 0.0.1-alpha.3

package/rust/core/preprocessor/dependencies.rs

@@ -1,54 +0,0 @@
-use std::{ collections::{ HashSet, VecDeque }, fs };
-
-pub fn collect_dependencies_recursively(entry_file: &str) -> Vec<String> {
-    let mut queue = VecDeque::new();
-    let mut loaded = HashSet::new();
-
-    queue.push_back(entry_file.to_string());
-
-    while let Some(file_ref) = queue.pop_front() {
-        if loaded.contains(&file_ref) {
-            continue;
-        }
-
-        let deps = get_direct_dependencies(&file_ref);
-        for dep in deps {
-            queue.push_back(dep.clone());
-        }
-
-        loaded.insert(file_ref);
-    }
-
-    loaded.into_iter().collect()
-}
-
-fn get_direct_dependencies(file: &str) -> Vec<String> {
-    let content = match fs::read_to_string(file) {
-        Ok(c) => c,
-        Err(_) => {
-            eprintln!("⚠️ Unable to read file: {}", file);
-            return vec![];
-        }
-    };
-
-    let mut deps = Vec::new();
-
-    for line in content.lines() {
-        let line = line.trim();
-
-        if line.starts_with("@import") {
-            if let Some(from_index) = line.find("from") {
-                let after_from = line[from_index + 4..].trim();
-                if after_from.starts_with('"') || after_from.starts_with('\'') {
-                    let delimiter = after_from.chars().next().unwrap();
-                    if let Some(end_quote) = after_from[1..].find(delimiter) {
-                        let path = &after_from[1..=end_quote];
-                        deps.push(path.to_string());
-                    }
-                }
-            }
-        }
-    }
-
-    deps
-}

package/rust/core/preprocessor/resolver/at.rs

@@ -1,24 +0,0 @@
-use crate::core::types::{
-    module::Module,
-    statement::{ Statement, StatementResolved, StatementResolvedValue },
-    variable::VariableValue,
-};
-
-pub fn resolve_load_statement(
-    stmt: &Statement,
-    source: &str,
-    alias: &str,
-    module: &mut Module
-) -> StatementResolved {
-    let source_string = source.to_string();
-
-    module.set_variable(alias.to_string(), VariableValue::Sample(source_string.clone()));
-
-    StatementResolved {
-        kind: stmt.kind.clone(),
-        value: StatementResolvedValue::Null,
-        indent: stmt.indent,
-        line: stmt.line,
-        column: stmt.column,
-    }
-}

package/rust/core/preprocessor/resolver/bank.rs

@@ -1,59 +0,0 @@
-use crate::core::{parser::parse_with_resolving_with_module, types::{
-    module::Module,
-    statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
-    variable::VariableValue,
-}};
-
-pub fn resolve_bank_statement(stmt: &Statement, module: &Module) -> StatementResolved {
-    match &stmt.value {
-        VariableValue::Text(name) => {
-            if
-                let Some(value) = module.import_table.imports
-                    .get(name)
-                    .or_else(|| module.variable_table.variables.get(name))
-            {
-                let statement_value: StatementResolvedValue = match value {
-                    VariableValue::Array(arr) => {
-                        StatementResolvedValue::Array(
-                            parse_with_resolving_with_module(arr.clone(), module)
-                        )
-                    }
-                    VariableValue::Text(text) => StatementResolvedValue::String(text.clone()),
-                    VariableValue::Number(num) => StatementResolvedValue::Number(*num),
-                    VariableValue::Boolean(b) => StatementResolvedValue::Boolean(*b),
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for Bank: {:?}", value);
-                        StatementResolvedValue::Unknown
-                    }
-                };
-
-                StatementResolved {
-                    kind: StatementKind::Bank,
-                    value: statement_value,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
-                }
-            } else {
-                eprintln!("⚠️ Bank variable '{}' not found", name);
-                StatementResolved {
-                    kind: StatementKind::Bank,
-                    value: StatementResolvedValue::Unknown,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
-                }
-            }
-        }
-        _ => {
-            eprintln!("⚠️ Invalid value type for Bank statement: {:?}", stmt.value);
-            StatementResolved {
-                kind: StatementKind::Bank,
-                value: StatementResolvedValue::Unknown,
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
-    }
-}

package/rust/core/preprocessor/resolver/loop_.rs

@@ -1,82 +0,0 @@
-use crate::core::{
-    parser::parse_without_resolving_with_module,
-    preprocessor::resolver::resolve_statement,
-    types::{
-        module::Module,
-        statement::{
-            Statement,
-            StatementIterator,
-            StatementKind,
-            StatementResolved,
-            StatementResolvedValue,
-        },
-        variable::VariableValue,
-    },
-};
-
-pub fn resolve_loop_statement(
-    loop_statement: &Statement,
-    iterator: StatementIterator,
-    module: &Module
-) -> StatementResolved {
-    let mut resolved_iterator = StatementIterator::Unknown;
-
-    match iterator.clone() {
-        StatementIterator::Identifier(id) => {
-            if let Some(value) = module.variable_table.variables.get(&id) {
-                match value {
-                    VariableValue::Array(arr) => {
-                        resolved_iterator = StatementIterator::Array(
-                            parse_without_resolving_with_module(arr.clone(), module)
-                        );
-                    }
-                    VariableValue::Number(num) => {
-                        resolved_iterator = StatementIterator::Number(*num);
-                    }
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for loop iterator: {:?}", value);
-                        resolved_iterator = StatementIterator::Unknown;
-                    }
-                }
-            } else {
-                eprintln!("⚠️ Loop iterator variable '{}' not found", id);
-                resolved_iterator = StatementIterator::Unknown;
-            }
-        }
-        StatementIterator::Number(num) => {
-            resolved_iterator = StatementIterator::Number(num);
-        }
-        _ => {
-            resolved_iterator = iterator.clone();
-        }
-    }
-
-    let mut resolved_body: StatementResolvedValue = StatementResolvedValue::Unknown;
-
-    match &loop_statement.value {
-        VariableValue::Array(arr) => {
-            let raw_statements = parse_without_resolving_with_module(arr.clone(), &module.clone());
-
-            let mut resolved_statements = Vec::new();
-
-            for raw_stmt in raw_statements {
-                let resolved_stmt = resolve_statement(&raw_stmt, &mut module.clone());
-                resolved_statements.push(resolved_stmt);
-            }
-
-            resolved_body = StatementResolvedValue::Array(resolved_statements);
-        }
-        _ => {
-            resolved_body = StatementResolvedValue::Unknown;
-            eprintln!("⚠️ Unsupported value type for loop body: {:?}", loop_statement.value);
-        }
-    }
-
-    return StatementResolved {
-        kind: StatementKind::Loop { iterator: resolved_iterator },
-        value: resolved_body,
-        indent: loop_statement.indent,
-        line: loop_statement.line,
-        column: loop_statement.column,
-    };
-}

package/rust/core/preprocessor/resolver/mod.rs

@@ -1,113 +0,0 @@
-pub mod bank;
-pub mod loop_;
-pub mod tempo;
-pub mod trigger;
-pub mod at;
-
-use crate::core::{
-    preprocessor::resolver::{
-        bank::resolve_bank_statement,
-        loop_::resolve_loop_statement,
-        tempo::resolve_tempo_statement,
-        trigger::resolve_trigger_statement,
-        at::{ resolve_load_statement },
-    },
-    types::{
-        module::Module,
-        parser::Parser,
-        statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
-        store::{ ExportTable, GlobalStore, ImportTable },
-        variable::VariableValue,
-    },
-};
-
-pub fn resolve_exports(statements: &[Statement], parser: &Parser) -> ExportTable {
-    let mut export_table = parser.export_table.clone();
-
-    for stmt in statements {
-        if let StatementKind::Export = &stmt.kind {
-            if let VariableValue::Array(tokens) = &stmt.value {
-                for token in tokens {
-                    let var_name = &token.lexeme;
-                    if let Some(value) = parser.variable_table.variables.get(var_name) {
-                        export_table.add_export(var_name.clone(), value.clone());
-                    } else {
-                        eprintln!("⚠️ Variable '{}' not found in scope, export skipped", var_name);
-                    }
-                }
-            } else {
-                eprintln!("⚠️ Unexpected value type in export: {:?}", stmt.value);
-            }
-        }
-    }
-
-    export_table
-}
-
-pub fn resolve_imports(module: &mut Module, global_store: &GlobalStore) -> ImportTable {
-    let mut import_table = ImportTable::default();
-
-    for stmt in &module.statements {
-        if let StatementKind::Import { names, source } = &stmt.kind {
-            if let Some(from_module) = global_store.modules.get(source) {
-                for name in names {
-                    if let Some(value) = from_module.export_table.exports.get(name) {
-                        module.variable_table.variables.insert(name.clone(), value.clone());
-                        import_table.add_import(name.clone(), value.clone());
-                    } else {
-                        eprintln!("⚠️ '{}' not found in exports of '{}'", name, source);
-                    }
-                }
-            } else {
-                eprintln!("⚠️ Module '{}' not found", source);
-            }
-        }
-    }
-
-    import_table
-}
-
-pub fn resolve_statement(stmt: &Statement, module: &mut Module) -> StatementResolved {
-    match &stmt.kind {
-        StatementKind::Loop { iterator } => {
-            resolve_loop_statement(stmt, iterator.clone(), module)
-        }
-
-        StatementKind::Trigger { entity, duration } => {
-            resolve_trigger_statement(stmt, entity.clone(), duration.clone(), module)
-        }
-
-        StatementKind::Bank { .. } => { resolve_bank_statement(stmt, module) }
-
-        StatementKind::Tempo { .. } => { resolve_tempo_statement(stmt, module) }
-
-        StatementKind::Load { source, alias } => {
-            resolve_load_statement(stmt, source, alias, module)
-        }
-
-        // TODO Handle other statement kinds
-
-        StatementKind::Error => {
-            StatementResolved {
-                kind: StatementKind::Error,
-                value: match stmt.value {
-                    VariableValue::Text(ref msg) => StatementResolvedValue::String(msg.clone()),
-                    _ => StatementResolvedValue::Unknown,
-                },
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
-
-        _ => {
-            StatementResolved {
-                kind: StatementKind::Unknown,
-                value: StatementResolvedValue::Unknown,
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
-    }
-}

package/rust/core/preprocessor/resolver/tempo.rs

@@ -1,70 +0,0 @@
-use crate::core::types::{module::Module, statement::{Statement, StatementKind, StatementResolved, StatementResolvedValue}, variable::VariableValue};
-
-pub fn resolve_tempo_statement(
-    tempo_statement: &Statement,
-    module: &Module
-) -> StatementResolved {
-    match &tempo_statement.value {
-        VariableValue::Number(num) => {
-            if *num > 0.0 {
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: StatementResolvedValue::Number(*num),
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
-            } else {
-                eprintln!("⚠️ Invalid tempo value: {}", num);
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: StatementResolvedValue::Unknown,
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
-            }
-        }
-        VariableValue::Text(text) => {
-            if let Some(value) = module.variable_table.variables.get(text) {
-                let variable_value: StatementResolvedValue = match value {
-                    VariableValue::Number(num) if *num > 0.0 => {
-                        StatementResolvedValue::Number(*num)
-                    }
-                    VariableValue::Text(t) => StatementResolvedValue::String(t.clone()),
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for Tempo: {:?}", value);
-                        StatementResolvedValue::Unknown
-                    }
-                };
-
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: variable_value,
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
-            } else {
-                eprintln!("⚠️ Tempo variable '{}' not found", text);
-                StatementResolved {
-                    kind: StatementKind::Tempo,
-                    value: StatementResolvedValue::Unknown,
-                    indent: tempo_statement.indent,
-                    line: tempo_statement.line,
-                    column: tempo_statement.column,
-                }
-            }
-        }
-        _ => {
-            eprintln!("⚠️ Invalid value type for Tempo statement: {:?}", tempo_statement.value);
-            StatementResolved {
-                kind: StatementKind::Tempo,
-                value: StatementResolvedValue::Unknown,
-                indent: tempo_statement.indent,
-                line: tempo_statement.line,
-                column: tempo_statement.column,
-            }
-        }
-    }
-}

package/rust/core/preprocessor/resolver/trigger.rs

@@ -1,176 +0,0 @@
-use std::collections::HashMap;
-
-use crate::core::{
-    parser::parse_with_resolving_with_module,
-    types::{
-        module::Module,
-        statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
-        token::{ TokenDuration, TokenParamValue },
-        variable::VariableValue,
-    },
-};
-
-pub fn resolve_trigger_statement(
-    stmt: &Statement,
-    entity: String,
-    duration: TokenDuration,
-    module: &Module
-) -> StatementResolved {
-    let mut entity_value = VariableValue::Unknown;
-
-    if let Some(value) = module.variable_table.variables.get(&entity) {
-        entity_value = value.clone();
-    } else {
-        entity_value = VariableValue::Text(entity.clone());
-    }
-
-    let duration_raw_value = match duration {
-        TokenDuration::Auto => "auto",
-        TokenDuration::Infinite => "infinite",
-        TokenDuration::Number(n) => &n.to_string(),
-        TokenDuration::Identifier(ref id) => id.as_str(),
-        _ => "unknown",
-    };
-
-    let duration_variable_value = module.variable_table.variables.get(duration_raw_value);
-    let mut parsed_duration_value = TokenDuration::Unknown;
-
-    if duration_variable_value.is_some() {
-        parsed_duration_value = duration_variable_value
-            .as_ref()
-            .map_or(TokenDuration::Unknown, |value| {
-                match value {
-                    VariableValue::Text(text) => TokenDuration::Identifier(text.clone()),
-                    VariableValue::Number(num) => TokenDuration::Number(*num),
-                    VariableValue::Boolean(_) => TokenDuration::Unknown,
-                    _ => {
-                        eprintln!("⚠️ Invalid duration type for Trigger: {:?}", value);
-                        TokenDuration::Unknown
-                    }
-                }
-            });
-    } else if let Ok(num) = duration_raw_value.parse::<f32>() {
-        parsed_duration_value = TokenDuration::Number(num);
-    } else if duration_raw_value == "auto" {
-        parsed_duration_value = TokenDuration::Auto;
-    } else if duration_raw_value == "infinite" {
-        parsed_duration_value = TokenDuration::Infinite;
-    } else {
-        eprintln!("⚠️ Invalid duration format: {}", duration_raw_value);
-    }
-
-    match &stmt.value {
-        VariableValue::Text(text) => {
-            if let Some(value) = module.variable_table.variables.get(text) {
-                let parsed_entity_value: StatementResolvedValue = match value {
-                    VariableValue::Array(arr) => {
-                        StatementResolvedValue::Array(
-                            parse_with_resolving_with_module(arr.clone(), module)
-                        )
-                    }
-                    VariableValue::Map(map) => {
-                        let mut resolved_map = HashMap::new();
-
-                        for (key, value) in map {
-                            let resolved_value = match value {
-                                TokenParamValue::String(text) =>
-                                    StatementResolvedValue::String(text.clone()),
-                                TokenParamValue::Number(num) =>
-                                    StatementResolvedValue::Number(*num),
-                                TokenParamValue::Boolean(b) => StatementResolvedValue::Boolean(*b),
-                                _ => {
-                                    eprintln!(
-                                        "⚠️ Unsupported variable type for Trigger map: {:?}",
-                                        value
-                                    );
-                                    StatementResolvedValue::Unknown
-                                }
-                            };
-                            resolved_map.insert(key.clone(), resolved_value);
-                        }
-
-                        StatementResolvedValue::Map(resolved_map)
-                    }
-
-                    | VariableValue::Text(_)
-                    | VariableValue::Number(_)
-                    | VariableValue::Boolean(_) => {
-                        StatementResolvedValue::String(text.clone())
-                    }
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for Trigger entity: {:?}", value);
-                        StatementResolvedValue::Unknown
-                    }
-                };
-
-                StatementResolved {
-                    kind: StatementKind::Trigger {
-                        entity: entity.clone(),
-                        duration: parsed_duration_value,
-                    },
-                    value: parsed_entity_value,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
-                }
-            } else {
-                eprintln!("⚠️ Trigger variable '{}' not found", text);
-                StatementResolved {
-                    kind: StatementKind::Trigger {
-                        entity: entity.clone(),
-                        duration: parsed_duration_value,
-                    },
-                    value: StatementResolvedValue::Unknown,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
-                }
-            }
-        }
-        VariableValue::Map(map) => {
-            let mut resolved_map = HashMap::new();
-
-            // TODO Handle nested maps and arrays
-
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Map(resolved_map),
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
-        VariableValue::Null => {
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Map(HashMap::new()),
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
-
-        // TODO Parse other parameters
-
-        _ => {
-            eprintln!("⚠️ Invalid value type for Trigger statement: {:?}", stmt.value);
-
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Unknown,
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
-        }
-    }
-}