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

package/rust/utils/src/logger.rs

@@ -1,200 +1,200 @@
-#[cfg(feature = "cli")]
-use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
-#[cfg(feature = "cli")]
-use std::fmt::Write;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum LogLevel {
-    Success,
-    Error,
-    Info,
-    Print,
-    Warning,
-    Watcher,
-    Debug,
-}
-
-#[derive(Debug, Clone)]
-pub struct Logger;
-
-impl Logger {
-    pub fn new() -> Self {
-        Logger
-    }
-
-    // Some methods are only used in CLI builds; silence dead_code warnings for non-cli.
-    #[cfg(not(feature = "cli"))]
-    #[allow(dead_code)]
-    fn __wasm_only_allow_dead_code(&self) {}
-
-    // Additionally allow dead_code for the CLI-only formatting helpers when building without cli
-    #[cfg(not(feature = "cli"))]
-    #[allow(dead_code)]
-    fn __wasm_only_format_helpers(&self) {}
-
-    #[cfg(feature = "cli")]
-    pub fn log_message(&self, level: LogLevel, message: &str) {
-        let formatted_status = self.format_status(level);
-        println!(
-            "🦊 {} {} {}",
-            self.language_signature(),
-            formatted_status,
-            message
-        );
-    }
-
-    #[cfg(not(feature = "cli"))]
-    pub fn log_message(&self, _level: LogLevel, _message: &str) {
-        // no-op for WASM
-    }
-
-    #[cfg(feature = "cli")]
-    pub fn log_message_with_trace(&self, level: LogLevel, message: &str, trace: Vec<&str>) {
-        let formatted_status = self.format_status(level);
-        println!(
-            "🦊 {} {} {}",
-            self.language_signature(),
-            formatted_status,
-            message
-        );
-        for t in trace {
-            println!("     ↳ {}", t);
-        }
-    }
-
-    #[cfg(not(feature = "cli"))]
-    pub fn log_message_with_trace(&self, _level: LogLevel, _message: &str, _trace: Vec<&str>) {
-        // no-op for WASM
-    }
-
-    #[cfg(feature = "cli")]
-    pub fn log_error_with_stacktrace(&self, message: &str, stacktrace: &str) {
-        let formatted_status = self.format_status(LogLevel::Error);
-        println!(
-            "🦊 {} {} {}",
-            self.language_signature(),
-            formatted_status,
-            message
-        );
-        println!("     ↳ {}", stacktrace);
-    }
-
-    #[cfg(not(feature = "cli"))]
-    pub fn log_error_with_stacktrace(&self, _message: &str, _stacktrace: &str) {
-        // no-op for WASM
-    }
-
-    #[cfg(feature = "cli")]
-    #[allow(dead_code)]
-    #[cfg_attr(not(feature = "cli"), allow(dead_code))]
-    fn language_signature(&self) -> String {
-        let mut s = String::new();
-
-        write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
-        s.push('[');
-
-        write!(
-            &mut s,
-            "{}",
-            SetForegroundColor(Color::Rgb {
-                r: 29,
-                g: 211,
-                b: 176,
-            })
-        )
-        .unwrap();
-        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
-        s.push_str("Devalang");
-        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
-
-        write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
-        s.push(']');
-        write!(&mut s, "{}", ResetColor).unwrap();
-
-        s
-    }
-
-    #[cfg(not(feature = "cli"))]
-    #[allow(dead_code)]
-    fn language_signature(&self) -> String {
-        "[Devalang]".to_string()
-    }
-
-    #[cfg(feature = "cli")]
-    fn format_status(&self, level: LogLevel) -> String {
-        let mut s = String::new();
-
-        let color = match level {
-            LogLevel::Success => Color::Rgb {
-                r: 76,
-                g: 175,
-                b: 80,
-            },
-            LogLevel::Error => Color::Rgb {
-                r: 244,
-                g: 67,
-                b: 54,
-            },
-            LogLevel::Info => Color::Rgb {
-                r: 33,
-                g: 150,
-                b: 243,
-            },
-            LogLevel::Warning => Color::Rgb {
-                r: 255,
-                g: 152,
-                b: 0,
-            },
-            LogLevel::Watcher => Color::Rgb {
-                r: 156,
-                g: 39,
-                b: 176,
-            },
-            LogLevel::Debug => Color::Rgb {
-                r: 103,
-                g: 58,
-                b: 183,
-            },
-            LogLevel::Print => Color::Rgb {
-                r: 255,
-                g: 255,
-                b: 255,
-            },
-        };
-
-        let status = match level {
-            LogLevel::Success => "SUCCESS",
-            LogLevel::Error => "ERROR",
-            LogLevel::Info => "INFO",
-            LogLevel::Warning => "WARNING",
-            LogLevel::Watcher => "WATCHER",
-            LogLevel::Debug => "DEBUG",
-            LogLevel::Print => "PRINT",
-        };
-
-        s.push('[');
-        write!(&mut s, "{}", SetForegroundColor(color)).unwrap();
-        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
-        s.push_str(status);
-        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
-        s.push(']');
-        write!(&mut s, "{}", ResetColor).unwrap();
-
-        s
-    }
-
-    #[cfg(not(feature = "cli"))]
-    #[allow(dead_code)]
-    fn format_status(&self, level: LogLevel) -> String {
-        (match level {
-            LogLevel::Success => "[SUCCESS]",
-            LogLevel::Error => "[ERROR]",
-            LogLevel::Info => "[INFO]",
-            LogLevel::Warning => "[WARNING]",
-            LogLevel::Watcher => "[WATCHER]",
-            LogLevel::Debug => "[DEBUG]",
-            LogLevel::Print => "[PRINT]",
-        })
-        .to_string()
-    }
-}
+#[cfg(feature = "cli")]
+use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
+#[cfg(feature = "cli")]
+use std::fmt::Write;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum LogLevel {
+    Success,
+    Error,
+    Info,
+    Print,
+    Warning,
+    Watcher,
+    Debug,
+}
+
+#[derive(Debug, Clone)]
+pub struct Logger;
+
+impl Logger {
+    pub fn new() -> Self {
+        Logger
+    }
+
+    // Some methods are only used in CLI builds; silence dead_code warnings for non-cli.
+    #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
+    fn __wasm_only_allow_dead_code(&self) {}
+
+    // Additionally allow dead_code for the CLI-only formatting helpers when building without cli
+    #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
+    fn __wasm_only_format_helpers(&self) {}
+
+    #[cfg(feature = "cli")]
+    pub fn log_message(&self, level: LogLevel, message: &str) {
+        let formatted_status = self.format_status(level);
+        println!(
+            "🦊 {} {} {}",
+            self.language_signature(),
+            formatted_status,
+            message
+        );
+    }
+
+    #[cfg(not(feature = "cli"))]
+    pub fn log_message(&self, _level: LogLevel, _message: &str) {
+        // no-op for WASM
+    }
+
+    #[cfg(feature = "cli")]
+    pub fn log_message_with_trace(&self, level: LogLevel, message: &str, trace: Vec<&str>) {
+        let formatted_status = self.format_status(level);
+        println!(
+            "🦊 {} {} {}",
+            self.language_signature(),
+            formatted_status,
+            message
+        );
+        for t in trace {
+            println!("     ↳ {}", t);
+        }
+    }
+
+    #[cfg(not(feature = "cli"))]
+    pub fn log_message_with_trace(&self, _level: LogLevel, _message: &str, _trace: Vec<&str>) {
+        // no-op for WASM
+    }
+
+    #[cfg(feature = "cli")]
+    pub fn log_error_with_stacktrace(&self, message: &str, stacktrace: &str) {
+        let formatted_status = self.format_status(LogLevel::Error);
+        println!(
+            "🦊 {} {} {}",
+            self.language_signature(),
+            formatted_status,
+            message
+        );
+        println!("     ↳ {}", stacktrace);
+    }
+
+    #[cfg(not(feature = "cli"))]
+    pub fn log_error_with_stacktrace(&self, _message: &str, _stacktrace: &str) {
+        // no-op for WASM
+    }
+
+    #[cfg(feature = "cli")]
+    #[allow(dead_code)]
+    #[cfg_attr(not(feature = "cli"), allow(dead_code))]
+    fn language_signature(&self) -> String {
+        let mut s = String::new();
+
+        write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
+        s.push('[');
+
+        write!(
+            &mut s,
+            "{}",
+            SetForegroundColor(Color::Rgb {
+                r: 29,
+                g: 211,
+                b: 176,
+            })
+        )
+        .unwrap();
+        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
+        s.push_str("Devalang");
+        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+
+        write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
+        s.push(']');
+        write!(&mut s, "{}", ResetColor).unwrap();
+
+        s
+    }
+
+    #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
+    fn language_signature(&self) -> String {
+        "[Devalang]".to_string()
+    }
+
+    #[cfg(feature = "cli")]
+    fn format_status(&self, level: LogLevel) -> String {
+        let mut s = String::new();
+
+        let color = match level {
+            LogLevel::Success => Color::Rgb {
+                r: 76,
+                g: 175,
+                b: 80,
+            },
+            LogLevel::Error => Color::Rgb {
+                r: 244,
+                g: 67,
+                b: 54,
+            },
+            LogLevel::Info => Color::Rgb {
+                r: 33,
+                g: 150,
+                b: 243,
+            },
+            LogLevel::Warning => Color::Rgb {
+                r: 255,
+                g: 152,
+                b: 0,
+            },
+            LogLevel::Watcher => Color::Rgb {
+                r: 156,
+                g: 39,
+                b: 176,
+            },
+            LogLevel::Debug => Color::Rgb {
+                r: 103,
+                g: 58,
+                b: 183,
+            },
+            LogLevel::Print => Color::Rgb {
+                r: 255,
+                g: 255,
+                b: 255,
+            },
+        };
+
+        let status = match level {
+            LogLevel::Success => "SUCCESS",
+            LogLevel::Error => "ERROR",
+            LogLevel::Info => "INFO",
+            LogLevel::Warning => "WARNING",
+            LogLevel::Watcher => "WATCHER",
+            LogLevel::Debug => "DEBUG",
+            LogLevel::Print => "PRINT",
+        };
+
+        s.push('[');
+        write!(&mut s, "{}", SetForegroundColor(color)).unwrap();
+        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
+        s.push_str(status);
+        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+        s.push(']');
+        write!(&mut s, "{}", ResetColor).unwrap();
+
+        s
+    }
+
+    #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
+    fn format_status(&self, level: LogLevel) -> String {
+        (match level {
+            LogLevel::Success => "[SUCCESS]",
+            LogLevel::Error => "[ERROR]",
+            LogLevel::Info => "[INFO]",
+            LogLevel::Warning => "[WARNING]",
+            LogLevel::Watcher => "[WATCHER]",
+            LogLevel::Debug => "[DEBUG]",
+            LogLevel::Print => "[PRINT]",
+        })
+        .to_string()
+    }
+}

package/rust/utils/src/path.rs

@@ -1,88 +1,129 @@
-use std::{
-    env, fs,
-    path::{Path, PathBuf},
-};
-
-pub const DEVALANG_CONFIG: &str = ".devalang";
-pub const DEVA_DIR: &str = ".deva";
-
-/// Returns the current working directory.
-pub fn get_cwd() -> PathBuf {
-    // In wasm (and some restricted environments) `env::current_dir()` is unsupported
-    // and will return an error. Avoid panicking here and fall back to `.` so the
-    // runtime can still operate in a virtual environment.
-    env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
-}
-
-/// Returns true if the given directory looks like a devalang project root.
-/// Preference is given to the presence of `.devalang` (config file),
-/// but falling back to a `.deva` directory is allowed.
-pub fn is_project_root(dir: &Path) -> bool {
-    let config = dir.join(DEVALANG_CONFIG);
-    if config.is_file() {
-        return true;
-    }
-    let deva = dir.join(DEVA_DIR);
-    deva.is_dir()
-}
-
-/// Walks upward from `start` to locate the first directory considered a project root.
-pub fn find_project_root_from(start: &Path) -> Option<PathBuf> {
-    for ancestor in start.ancestors() {
-        if is_project_root(ancestor) {
-            return Some(ancestor.to_path_buf());
-        }
-    }
-    None
-}
-
-/// Finds the project root from the current working directory.
-pub fn find_project_root() -> Option<PathBuf> {
-    find_project_root_from(&get_cwd())
-}
-
-/// Finds the package root using the `CARGO_MANIFEST_DIR` env var set by Cargo.
-pub fn get_package_root() -> Option<PathBuf> {
-    let cargo_dir = env::var("CARGO_MANIFEST_DIR").ok()?;
-    Some(PathBuf::from(cargo_dir))
-}
-
-/// Gets the project root or returns a descriptive error if not found.
-pub fn get_project_root() -> Result<PathBuf, String> {
-    find_project_root()
-        .ok_or_else(|| "Project root not found. Run 'devalang init' in your project.".to_string())
-}
-
-/// Returns the path to `.devalang` in the project root, ensuring it exists.
-pub fn get_devalang_config_path() -> Result<PathBuf, String> {
-    let root = get_project_root()?;
-    let config_path = root.join(DEVALANG_CONFIG);
-    if !config_path.exists() {
-        return Err(format!(
-            "Config file not found at '{}'. Please run 'devalang init' before continuing.",
-            config_path.display()
-        ));
-    }
-    Ok(config_path)
-}
-
-/// Returns the `.deva` directory inside the project root (without creating it).
-pub fn get_deva_dir() -> Result<PathBuf, String> {
-    let root = get_project_root()?;
-    Ok(root.join(DEVA_DIR))
-}
-
-/// Ensures the `.deva` directory exists in the project root and returns its path.
-pub fn ensure_deva_dir() -> Result<PathBuf, String> {
-    let deva = get_deva_dir()?;
-    if !deva.exists() {
-        fs::create_dir_all(&deva).map_err(|e| {
-            format!(
-                "Failed to create Deva directory '{}': {}",
-                deva.display(),
-                e
-            )
-        })?;
-    }
-    Ok(deva)
-}
+use std::{
+    env, fs,
+    path::{Path, PathBuf},
+};
+
+pub const DEVALANG_CONFIG: &str = ".devalang";
+pub const DEVA_DIR: &str = ".deva";
+
+/// Returns the current working directory.
+pub fn get_cwd() -> PathBuf {
+    // In wasm (and some restricted environments) `env::current_dir()` is unsupported
+    // and will return an error. Avoid panicking here and fall back to `.` so the
+    // runtime can still operate in a virtual environment.
+    env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
+}
+
+/// Returns true if the given directory looks like a devalang project root.
+/// Preference is given to the presence of `.devalang` (config file),
+/// but falling back to a `.deva` directory is allowed.
+pub fn is_project_root(dir: &Path) -> bool {
+    let config = dir.join(DEVALANG_CONFIG);
+    if config.is_file() {
+        return true;
+    }
+    let deva = dir.join(DEVA_DIR);
+    deva.is_dir()
+}
+
+/// Walks upward from `start` to locate the first directory considered a project root.
+pub fn find_project_root_from(start: &Path) -> Option<PathBuf> {
+    for ancestor in start.ancestors() {
+        if is_project_root(ancestor) {
+            return Some(ancestor.to_path_buf());
+        }
+    }
+    None
+}
+
+/// Finds the project root from the current working directory.
+pub fn find_project_root() -> Option<PathBuf> {
+    find_project_root_from(&get_cwd())
+}
+
+/// Finds the package root using the `CARGO_MANIFEST_DIR` env var set by Cargo.
+pub fn get_package_root() -> Option<PathBuf> {
+    let cargo_dir = env::var("CARGO_MANIFEST_DIR").ok()?;
+    Some(PathBuf::from(cargo_dir))
+}
+
+/// Gets the project root or returns a descriptive error if not found.
+pub fn get_project_root() -> Result<PathBuf, String> {
+    find_project_root()
+        .ok_or_else(|| "Project root not found. Run 'devalang init' in your project.".to_string())
+}
+
+/// Returns the path to `.devalang` in the project root, ensuring it exists.
+pub fn get_devalang_config_path() -> Result<PathBuf, String> {
+    let root = get_project_root()?;
+    let config_path = root.join(DEVALANG_CONFIG);
+    if !config_path.exists() {
+        return Err(format!(
+            "Config file not found at '{}'. Please run 'devalang init' before continuing.",
+            config_path.display()
+        ));
+    }
+    Ok(config_path)
+}
+
+/// Returns the `.deva` directory inside the project root (without creating it).
+pub fn get_deva_dir() -> Result<PathBuf, String> {
+    let root = get_project_root()?;
+    Ok(root.join(DEVA_DIR))
+}
+
+/// Ensures the `.deva` directory exists in the project root and returns its path.
+pub fn ensure_deva_dir() -> Result<PathBuf, String> {
+    let deva = get_deva_dir()?;
+    if !deva.exists() {
+        fs::create_dir_all(&deva).map_err(|e| {
+            format!(
+                "Failed to create Deva directory '{}': {}",
+                deva.display(),
+                e
+            )
+        })?;
+    }
+    Ok(deva)
+}
+
+/// Finds the entry file given a path, returning the normalized path if found.
+/// If the path is a directory, it looks for `index.deva` inside it.
+/// Returns None if no valid entry file is found.
+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
+}
+
+/// Normalizes a path to use forward slashes and removes redundant components.
+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('\\', "/")
+}
+
+/// Resolves a relative import path against a base path, normalizing the result.
+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("\\", "/")
+}