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

package/rust/cli/init.rs

@@ -1,79 +1,87 @@
-use std::{ fs, path::Path };
-use include_dir::{ include_dir, Dir };
-use crate::{ cli::template::get_available_templates, utils::file::copy_dir_recursive };
-
-#[cfg(feature = "cli")]
-use inquire::{ Select, Confirm };
-
-static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
-
-#[cfg(feature = "cli")]
-pub fn handle_init_command(name: Option<String>, template: Option<String>) {
-    let current_dir = std::env::current_dir().unwrap();
-    let project_name = name
-        .clone()
-        .unwrap_or_else(|| {
-            current_dir.file_name().unwrap_or_default().to_string_lossy().to_string()
-        });
-
-    // Select a template if not provided
-    let selected_template = template.unwrap_or_else(|| {
-        Select::new("Select a template for your project:", get_available_templates())
-            .prompt()
-            .unwrap_or_else(|_| {
-                eprintln!("No template selected. Exiting...");
-                std::process::exit(1);
-            })
-    });
-
-    if selected_template.is_empty() {
-        eprintln!("Template cannot be empty.");
-        std::process::exit(1);
-    }
-
-    if name.is_none() {
-        // Case of initialization in the current directory
-        if fs::read_dir(&current_dir).unwrap().next().is_some() {
-            let confirm = Confirm::new(
-                "The current directory is not empty. Do you want to continue?"
-            )
-                .with_default(false)
-                .prompt()
-                .unwrap_or(false);
-
-            if !confirm {
-                eprintln!("Operation cancelled by the user.");
-                std::process::exit(0);
-            }
-        }
-
-        scaffold_project_current_dir(current_dir.as_path(), selected_template);
-        println!(
-            "✅ Initialized '{}' project in current directory: {}",
-            project_name,
-            current_dir.display()
-        );
-    } else {
-        // Case of initialization in a new directory
-        let target_path = current_dir.join(&project_name);
-
-        if target_path.exists() {
-            eprintln!("❌ A folder named '{}' already exists.", project_name);
-            std::process::exit(1);
-        }
-
-        fs::create_dir_all(&target_path).expect("Error creating project directory");
-
-        scaffold_project_current_dir(&target_path, selected_template);
-        println!("✅ Initialized '{}' project in: {}", project_name, target_path.display());
-    }
-}
-
-fn scaffold_project_current_dir(path: &Path, template: String) {
-    let template_dir = TEMPLATES_DIR.get_dir(&template).unwrap_or_else(|| {
-        eprintln!("❌ The template '{}' doesn't exist.", template);
-        std::process::exit(1);
-    });
-
-    copy_dir_recursive(template_dir, path, &template_dir.path());
-}
+use crate::{cli::template::get_available_templates, utils::file::copy_dir_recursive};
+use include_dir::{Dir, include_dir};
+use std::{fs, path::Path};
+
+#[cfg(feature = "cli")]
+use inquire::{Confirm, Select};
+
+static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
+
+#[cfg(feature = "cli")]
+pub fn handle_init_command(name: Option<String>, template: Option<String>) {
+    let current_dir = std::env::current_dir().unwrap();
+    let project_name = name.clone().unwrap_or_else(|| {
+        current_dir
+            .file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .to_string()
+    });
+
+    // Select a template if not provided
+    let selected_template = template.unwrap_or_else(|| {
+        Select::new(
+            "Select a template for your project:",
+            get_available_templates(),
+        )
+        .prompt()
+        .unwrap_or_else(|_| {
+            eprintln!("No template selected. Exiting...");
+            std::process::exit(1);
+        })
+    });
+
+    if selected_template.is_empty() {
+        eprintln!("Template cannot be empty.");
+        std::process::exit(1);
+    }
+
+    if name.is_none() {
+        // Case of initialization in the current directory
+        if fs::read_dir(&current_dir).unwrap().next().is_some() {
+            let confirm =
+                Confirm::new("The current directory is not empty. Do you want to continue?")
+                    .with_default(false)
+                    .prompt()
+                    .unwrap_or(false);
+
+            if !confirm {
+                eprintln!("Operation cancelled by the user.");
+                std::process::exit(0);
+            }
+        }
+
+        scaffold_project_current_dir(current_dir.as_path(), selected_template);
+        println!(
+            "✅ Initialized '{}' project in current directory: {}",
+            project_name,
+            current_dir.display()
+        );
+    } else {
+        // Case of initialization in a new directory
+        let target_path = current_dir.join(&project_name);
+
+        if target_path.exists() {
+            eprintln!("❌ A folder named '{}' already exists.", project_name);
+            std::process::exit(1);
+        }
+
+        fs::create_dir_all(&target_path).expect("Error creating project directory");
+
+        scaffold_project_current_dir(&target_path, selected_template);
+        println!(
+            "✅ Initialized '{}' project in: {}",
+            project_name,
+            target_path.display()
+        );
+    }
+}
+
+fn scaffold_project_current_dir(path: &Path, template: String) {
+    let template_dir = TEMPLATES_DIR.get_dir(&template).unwrap_or_else(|| {
+        eprintln!("❌ The template '{}' doesn't exist.", template);
+        std::process::exit(1);
+    });
+
+    copy_dir_recursive(template_dir, path, &template_dir.path());
+}

package/rust/cli/install.rs

@@ -1,32 +1,35 @@
-use crate::installer::addon::{ install_addon, AddonType };
-
-/// Handles the installation command for a given addon type and name.
-#[cfg(feature = "cli")]
-pub async fn handle_install_command(name: String, addon_type: AddonType) -> Result<(), String> {
-    use crate::utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner };
-    use std::{ thread, time::Duration };
-
-    let logger = Logger::new();
-    let deva_dir = std::path::Path::new("./.deva/");
-
-    let spinner = with_spinner("Installing...", || {
-        thread::sleep(Duration::from_millis(800));
-    });
-
-    if let Err(e) = install_addon(addon_type.clone(), name.as_str(), deva_dir).await {
-        spinner.finish_and_clear();
-        logger.log_message_with_trace(
-            LogLevel::Error,
-            &format!("Error installing {:?} '{}'", addon_type, name),
-            vec![&e]
-        );
-    } else {
-        spinner.finish_and_clear();
-        logger.log_message(
-            LogLevel::Success,
-            &format!("{:?} '{}' installed successfully!", addon_type, name)
-        );
-    }
-
-    Ok(())
-}
+use crate::installer::addon::{AddonType, install_addon};
+
+/// Handles the installation command for a given addon type and name.
+#[cfg(feature = "cli")]
+pub async fn handle_install_command(name: String, addon_type: AddonType) -> Result<(), String> {
+    use crate::utils::{
+        logger::{LogLevel, Logger},
+        spinner::with_spinner,
+    };
+    use std::{thread, time::Duration};
+
+    let logger = Logger::new();
+    let deva_dir = std::path::Path::new("./.deva/");
+
+    let spinner = with_spinner("Installing...", || {
+        thread::sleep(Duration::from_millis(800));
+    });
+
+    if let Err(e) = install_addon(addon_type.clone(), name.as_str(), deva_dir).await {
+        spinner.finish_and_clear();
+        logger.log_message_with_trace(
+            LogLevel::Error,
+            &format!("Error installing {:?} '{}'", addon_type, name),
+            vec![&e],
+        );
+    } else {
+        spinner.finish_and_clear();
+        logger.log_message(
+            LogLevel::Success,
+            &format!("{:?} '{}' installed successfully!", addon_type, name),
+        );
+    }
+
+    Ok(())
+}

package/rust/cli/login.rs

@@ -1,134 +1,127 @@
-use std::fs;
-use tiny_http::{ Server, Response };
-use webbrowser;
-use serde::{ Serialize, Deserialize };
-use dirs::home_dir;
-use crate::common::sso::get_sso_url;
-use std::{ thread, time::Duration };
-use tiny_http::Header;
-use std::str::FromStr;
-
-#[derive(Serialize, Deserialize)]
-struct UserConfig {
-    token: String,
-}
-
-/// Handle the login command
-/// This function initiates the login process by opening the browser and waiting for the callback.
-#[cfg(feature = "cli")]
-pub async fn handle_login_command() -> Result<(), String> {
-    use crate::utils::spinner::with_spinner;
-    use crate::utils::logger::Logger;
-    use crate::utils::logger::LogLevel;
-
-    let logger = Logger::new();
-
-    let mut listener_port = 7878;
-
-    let test_port_already_in_use = format!("127.0.0.1:{}", listener_port);
-    while std::net::TcpListener::bind(&test_port_already_in_use).is_err() {
-        listener_port += 1;
-    }
-
-    let redirect_uri = format!("http://127.0.0.1:{}/callback", listener_port);
-    let login_url = format!(
-        "{}/?response_type=code&referer=cli&redirect_uri={}",
-        get_sso_url(),
-        redirect_uri
-    );
-
-    if webbrowser::open(&login_url).is_ok() {
-        logger.log_message(LogLevel::Info, "Opening browser for login...");
-        logger.log_message(
-            LogLevel::Info,
-            &format!("If the browser does not open, please visit the following URL: {}", login_url)
-        );
-    } else {
-        logger.log_message(
-            LogLevel::Info,
-            "Please open the following URL in your browser to login:"
-        );
-        logger.log_message(LogLevel::Info, &login_url);
-    }
-
-    let server = Server::http(format!("127.0.0.1:{}", listener_port)).unwrap();
-
-    let spinner = with_spinner("Waiting for authentication...", || {
-        thread::sleep(Duration::from_millis(800));
-    });
-
-    for request in server.incoming_requests() {
-        let query = request.url().to_string();
-        if request.url().starts_with("/callback") {
-            if query.contains("session=") || query.contains("error=") {
-                let token = query.split("session=").nth(1).unwrap_or("").to_string();
-
-                if token.len() > 0 {
-                    let response_html =
-                        r#"
-                        <html>
-                            <body>
-                                <h1>Authentication Successful</h1>
-                                <h2>You can now close this window.</h2>
-                            </body>
-                        </html>
-                    "#;
-
-                    let response = Response::from_string(response_html)
-                        .with_status_code(200)
-                        .with_header(Header::from_str("Content-Type: text/html").unwrap());
-
-                    request.respond(response).unwrap();
-
-                    save_token(&token);
-
-                    spinner.finish_and_clear();
-
-                    logger.log_message(
-                        LogLevel::Success,
-                        "Authentication successful. Token saved to ~/.devalang/session_token.json"
-                    );
-
-                    break;
-                } else {
-                    spinner.finish_and_clear();
-                    logger.log_message(LogLevel::Error, "Invalid session token.");
-                    request.respond(Response::from_string("Invalid session token.")).unwrap();
-
-                    break;
-                }
-            } else {
-                println!("Invalid callback: {}", request.url());
-
-                spinner.finish_and_clear();
-                logger.log_message(LogLevel::Error, "Invalid callback.");
-                request.respond(Response::from_string("Invalid callback.")).unwrap();
-
-                break;
-            }
-        } else if request.url().starts_with("/favicon.ico") {
-            // Ignore favicon requests
-        } else {
-            spinner.finish_and_clear();
-            logger.log_message(LogLevel::Error, "Invalid request.");
-            request.respond(Response::from_string("Invalid request.")).unwrap();
-
-            break;
-        }
-    }
-
-    Ok(())
-}
-
-/// Save the session token to a file in the user's home directory
-fn save_token(token: &str) {
-    let config = UserConfig { token: token.to_string() };
-    let json = serde_json::to_string(&config).unwrap();
-
-    let mut path = home_dir().unwrap();
-    path.push(".devalang");
-    fs::create_dir_all(&path).unwrap();
-
-    path.push("session_token.json");
-    fs::write(path, json).unwrap();
-}
+use crate::common::sso::get_sso_url;
+use crate::config::settings::set_user_config_string;
+use std::str::FromStr;
+use std::{thread, time::Duration};
+use tiny_http::Header;
+use tiny_http::{Response, Server};
+use webbrowser;
+
+/// Handle the login command
+/// This function initiates the login process by opening the browser and waiting for the callback.
+#[cfg(feature = "cli")]
+pub async fn handle_login_command() -> Result<(), String> {
+    use crate::utils::logger::LogLevel;
+    use crate::utils::logger::Logger;
+    use crate::utils::spinner::with_spinner;
+
+    let logger = Logger::new();
+
+    let mut listener_port = 7878;
+
+    let test_port_already_in_use = format!("127.0.0.1:{}", listener_port);
+    while std::net::TcpListener::bind(&test_port_already_in_use).is_err() {
+        listener_port += 1;
+    }
+
+    let redirect_uri = format!("http://127.0.0.1:{}/callback", listener_port);
+    let login_url = format!(
+        "{}/?response_type=code&referer=cli&redirect_uri={}",
+        get_sso_url(),
+        redirect_uri
+    );
+
+    if webbrowser::open(&login_url).is_ok() {
+        logger.log_message(LogLevel::Info, "Opening browser for login...");
+        logger.log_message(
+            LogLevel::Info,
+            &format!(
+                "If the browser does not open, please visit the following URL: {}",
+                login_url
+            ),
+        );
+    } else {
+        logger.log_message(
+            LogLevel::Info,
+            "Please open the following URL in your browser to login:",
+        );
+        logger.log_message(LogLevel::Info, &login_url);
+    }
+
+    let server = Server::http(format!("127.0.0.1:{}", listener_port)).unwrap();
+
+    let spinner = with_spinner("Waiting for authentication...", || {
+        thread::sleep(Duration::from_millis(800));
+    });
+
+    for request in server.incoming_requests() {
+        let query = request.url().to_string();
+        if request.url().starts_with("/callback") {
+            if query.contains("session=") || query.contains("error=") {
+                let token = query.split("session=").nth(1).unwrap_or("").to_string();
+
+                if token.len() > 0 {
+                    let response_html = r#"
+                        <html>
+                            <body>
+                                <h1>Authentication Successful</h1>
+                                <h2>You can now close this window.</h2>
+                            </body>
+                        </html>
+                    "#;
+
+                    let response = Response::from_string(response_html)
+                        .with_status_code(200)
+                        .with_header(Header::from_str("Content-Type: text/html").unwrap());
+
+                    request.respond(response).unwrap();
+
+                    save_token(&token);
+
+                    spinner.finish_and_clear();
+
+                    logger.log_message(
+                        LogLevel::Success,
+                        "Authentication successful. Token saved to ~/.devalang/config.json",
+                    );
+
+                    break;
+                } else {
+                    spinner.finish_and_clear();
+                    logger.log_message(LogLevel::Error, "Invalid session token.");
+                    request
+                        .respond(Response::from_string("Invalid session token."))
+                        .unwrap();
+
+                    break;
+                }
+            } else {
+                println!("Invalid callback: {}", request.url());
+
+                spinner.finish_and_clear();
+                logger.log_message(LogLevel::Error, "Invalid callback.");
+                request
+                    .respond(Response::from_string("Invalid callback."))
+                    .unwrap();
+
+                break;
+            }
+        } else if request.url().starts_with("/favicon.ico") {
+            // Ignore favicon requests
+        } else {
+            spinner.finish_and_clear();
+            logger.log_message(LogLevel::Error, "Invalid request.");
+            request
+                .respond(Response::from_string("Invalid request."))
+                .unwrap();
+
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+/// Save the session token to a file in the user's home directory
+fn save_token(token: &str) {
+    set_user_config_string("session", token.to_string());
+}

package/rust/cli/mod.rs

@@ -1,11 +1,13 @@
-pub mod driver;
-
-pub mod check;
-pub mod build;
-pub mod init;
-pub mod template;
-pub mod play;
-pub mod install;
-pub mod bank;
-pub mod update;
-pub mod login;
+pub mod driver;
+
+pub mod bank;
+pub mod build;
+pub mod check;
+pub mod generator;
+pub mod init;
+pub mod install;
+pub mod login;
+pub mod play;
+pub mod telemetry;
+pub mod template;
+pub mod update;