Hello hyperlane: {{ time }}

Server: Hyperlane ``` # Path: hyperlane-quick-start/resources/static/not_found/index.html ```html

404 Not Found

Server: Hyperlane ``` # Path: hyperlane-cli/README.md # hyperlane-cli [Official Documentation](https://docs.ltpp.vip/hyperlane-cli/) [Api Docs](https://docs.rs/hyperlane-cli/latest/) ## Description > A command-line tool for Hyperlane framework. ## Installation To install `hyperlane-cli` run cmd: ```shell cargo add hyperlane-cli ``` ## Contact # Path: hyperlane-cli/src/main.rs ```rust mod bump; mod command; mod config; mod fmt; mod help; mod new; mod publish; mod template; mod version; mod watch; pub(crate) use { bump::*, command::*, config::*, fmt::*, help::*, new::*, publish::*, template::*, version::*, watch::*, }; pub(crate) use std::{ collections::{HashMap, VecDeque}, env::args, fs::{create_dir_all, read_to_string, write}, path::{Path, PathBuf}, process::{ExitStatus, Stdio, exit}, str::FromStr, sync::{Arc, LazyLock}, }; pub(crate) use { regex::{Captures, Regex}, tokio::{process::Command, sync::Mutex}, }; #[tokio::main] async fn main() { let args: Args = parse_args(); match args.command { CommandType::Fmt => { if let Err(error) = execute_fmt(&args).await { eprintln!("fmt failed: {error}"); exit(1); } } CommandType::Watch => { if let Err(error) = execute_watch().await { eprintln!("watch failed: {error}"); exit(1); } } CommandType::Bump => { let manifest_path: String = args .manifest_path .unwrap_or_else(|| "Cargo.toml".to_string()); let bump_type: BumpVersionType = args.bump_type.unwrap_or(BumpVersionType::Patch); match execute_bump(&manifest_path, &bump_type) { Ok(new_version) => { println!("Version bumped to {new_version}"); } Err(error) => { eprintln!("bump failed: {error}"); exit(1); } } } CommandType::Publish => { let manifest_path: String = args .manifest_path .unwrap_or_else(|| "Cargo.toml".to_string()); let max_retries: u32 = args.max_retries; match execute_publish(&manifest_path, max_retries).await { Ok(results) => { let failed_count: usize = results .iter() .filter(|r: &&PublishResult| !r.success) .count(); if failed_count > 0 { eprintln!("Publish completed with {failed_count} failures"); exit(1); } else { println!("All packages published successfully"); } } Err(error) => { eprintln!("publish failed: {error}"); exit(1); } } } CommandType::New => { if let Some(project_name) = args.project_name { if let Err(error) = execute_new(&project_name).await { eprintln!("new failed: {error}"); exit(1); } } else { eprintln!( "Error: Project name is required. Usage: hyperlane-cli new " ); exit(1); } } CommandType::Template => { let template_type: TemplateType = match args.template_type { Some(tt) => tt, None => { eprintln!( "Error: Template type is required. Usage: hyperlane-cli template [SUBTYPE] " ); exit(1); } }; let component_name: String = match args.component_name { Some(cn) => cn, None => { eprintln!( "Error: Component name is required. Usage: hyperlane-cli template [SUBTYPE] " ); exit(1); } }; if template_type == TemplateType::Model && args.model_sub_type.is_none() { eprintln!("Error: Model type requires subtype (application|request|response)"); exit(1); } if let Err(error) = execute_template(template_type, &component_name, args.model_sub_type).await { eprintln!("template failed: {error}"); exit(1); } } CommandType::Help => print_help(), CommandType::Version => print_version(), } } ``` # Path: hyperlane-cli/src/fmt/mod.rs ```rust mod r#fn; mod r#static; #[cfg(test)] mod test; pub(crate) use {r#fn::*, r#static::*}; ``` # Path: hyperlane-cli/src/fmt/fn.rs ```rust use crate::*; fn sort_derive_in_line(line: &str) -> Option { let captures: Captures<'_> = DERIVE_REGEX.captures(line)?; let derive_content: &str = captures.get(1)?.as_str(); let mut traits: Vec = derive_content .split(',') .map(|s: &str| s.trim().to_string()) .filter(|s: &String| !s.is_empty()) .collect(); traits.sort_by_key(|a| a.to_lowercase()); let sorted_traits: String = traits.join(", "); let result: String = line.replace(derive_content, &sorted_traits); Some(result) } async fn format_derive_in_file(file_path: &Path) -> Result { let content: String = read_to_string(file_path)?; let lines: std::str::Lines<'_> = content.lines(); let mut modified: bool = false; let mut new_content: String = String::new(); for line in lines { let trimmed: &str = line.trim(); let new_line: String = if trimmed.starts_with("#[derive(") { if let Some(sorted) = sort_derive_in_line(line) { if sorted != line { modified = true; } sorted } else { line.to_string() } } else { line.to_string() }; new_content.push_str(&new_line); new_content.push('\n'); } if modified { write(file_path, new_content)?; } Ok(modified) } async fn find_rust_files(manifest_path: &Path) -> Result, std::io::Error> { let mut files: Vec = Vec::new(); let workspace_root: &Path = manifest_path.parent().unwrap_or(Path::new(".")); let src_dir: PathBuf = workspace_root.join("src"); if src_dir.exists() { find_rust_files_in_dir(&src_dir, &mut files).await?; } let content: String = read_to_string(manifest_path)?; if let Ok(doc) = toml::from_str::(&content) && let Some(workspace) = doc.get("workspace") && let Some(members) = workspace .get("members") .and_then(|m: &toml::Value| m.as_array()) { for member in members { if let Some(pattern) = member.as_str() { let member_src: PathBuf = workspace_root.join(pattern).join("src"); if member_src.exists() { find_rust_files_in_dir(&member_src, &mut files).await?; } } } } Ok(files) } async fn find_rust_files_in_dir( dir: &Path, files: &mut Vec, ) -> Result<(), std::io::Error> { let mut entries = tokio::fs::read_dir(dir).await?; while let Some(entry) = entries.next_entry().await? { let path: PathBuf = entry.path(); if path.is_file() && path .extension() .is_some_and(|ext: &std::ffi::OsStr| ext == "rs") { files.push(path); } else if path.is_dir() { Box::pin(find_rust_files_in_dir(&path, files)).await?; } } Ok(()) } async fn format_derive_attributes(manifest_path: &str) -> Result<(), std::io::Error> { let path: &Path = Path::new(manifest_path); let files: Vec = find_rust_files(path).await?; let modified_count: Arc> = Arc::new(Mutex::new(0)); let mut handles: Vec>> = Vec::new(); for file in files { let counter: Arc> = Arc::clone(&modified_count); let handle: tokio::task::JoinHandle> = tokio::spawn(async move { if format_derive_in_file(&file).await? { let mut count: tokio::sync::MutexGuard<'_, usize> = counter.lock().await; *count += 1; } Ok(()) }); handles.push(handle); } for handle in handles { handle.await??; } let count: usize = *modified_count.lock().await; if count > 0 { println!("Sorted derive attributes in {count} files"); } Ok(()) } async fn is_cargo_clippy_installed() -> bool { Command::new("cargo") .arg("clippy") .arg("--version") .stdout(Stdio::null()) .stderr(Stdio::null()) .status() .await .is_ok_and(|status: ExitStatus| status.success()) } async fn install_cargo_clippy() -> Result<(), std::io::Error> { println!("cargo-clippy not found, installing..."); let mut cmd: Command = Command::new("rustup"); cmd.arg("component").arg("add").arg("clippy"); cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit()); let status: ExitStatus = cmd.status().await?; if !status.success() { return Err(std::io::Error::other("failed to install cargo-clippy")); } Ok(()) } async fn execute_clippy_fix(args: &Args) -> Result<(), std::io::Error> { if !is_cargo_clippy_installed().await { install_cargo_clippy().await?; } let mut cmd: Command = Command::new("cargo"); cmd.arg("clippy") .arg("--fix") .arg("--workspace") .arg("--all-targets") .arg("--allow-dirty"); if let Some(ref manifest_path) = args.manifest_path { cmd.arg("--manifest-path").arg(manifest_path); } cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit()); let status: ExitStatus = cmd.status().await?; if !status.success() { return Err(std::io::Error::other("cargo clippy --fix failed")); } Ok(()) } pub(crate) async fn execute_fmt(args: &Args) -> Result<(), std::io::Error> { let manifest_path: String = args .manifest_path .clone() .unwrap_or_else(|| "Cargo.toml".to_string()); if !args.check { format_derive_attributes(&manifest_path).await?; } let mut cmd: Command = Command::new("cargo"); cmd.arg("fmt"); if args.check { cmd.arg("--check"); } if let Some(ref manifest_path) = args.manifest_path { cmd.arg("--manifest-path").arg(manifest_path); } cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit()); let status: ExitStatus = cmd.status().await?; if !status.success() { return Err(std::io::Error::other("cargo fmt failed")); } if !args.check { execute_clippy_fix(args).await?; } Ok(()) } pub(crate) async fn format_path(path: &std::path::Path) -> Result<(), std::io::Error> { let mut cmd: Command = Command::new("cargo"); cmd.arg("fmt").arg("--").arg(path); cmd.stdout(Stdio::null()).stderr(Stdio::null()); cmd.status().await?; Ok(()) } ``` # Path: hyperlane-cli/src/fmt/static.rs ```rust use crate::*; pub(crate) static DERIVE_REGEX: LazyLock = LazyLock::new(|| { regex::Regex::new(r"#\[derive\s*\(([^)]+)\)\]").expect("Invalid regex pattern") }); ``` # Path: hyperlane-cli/src/fmt/test.rs ```rust use crate::*; #[test] fn test_format_path_integration() { use std::path::PathBuf; let tmp_dir: PathBuf = PathBuf::from("./tmp/test_fmt"); let _ = std::fs::create_dir_all(&tmp_dir); let test_file: PathBuf = tmp_dir.join("test.rs"); std::fs::write(&test_file, "fn main() {\n println!(\"hello\");\n}\n").unwrap(); let rt: tokio::runtime::Runtime = tokio::runtime::Runtime::new().unwrap(); let result: Result<(), std::io::Error> = rt.block_on(format_path(&tmp_dir)); assert!(result.is_ok()); } ``` # Path: hyperlane-cli/src/template/mod.rs ```rust mod r#enum; mod r#fn; mod r#impl; mod r#struct; #[cfg(test)] mod test; pub(crate) use {r#enum::*, r#fn::*, r#struct::*}; ``` # Path: hyperlane-cli/src/template/fn.rs ```rust use crate::*; fn get_directory_name(template_type: &TemplateType) -> String { match template_type { TemplateType::Controller => "controller".to_string(), TemplateType::Domain => "domain".to_string(), TemplateType::Exception => "exception".to_string(), TemplateType::Mapper => "mapper".to_string(), TemplateType::Model => "model".to_string(), TemplateType::Repository => "repository".to_string(), TemplateType::Service => "service".to_string(), TemplateType::Utils => "utils".to_string(), TemplateType::View => "view".to_string(), } } fn get_model_sub_type_name(sub_type: &ModelSubType) -> String { match sub_type { ModelSubType::Application => "application".to_string(), ModelSubType::Request => "request".to_string(), ModelSubType::Response => "response".to_string(), } } fn ensure_directory(path: &Path) -> Result<(), TemplateError> { if !path.exists() { create_dir_all(path)?; } Ok(()) } fn write_mod_rs(path: &Path, modules: &[&str]) -> Result<(), TemplateError> { let mut content: String = String::new(); for module in modules { let mod_name: String = if module.starts_with("r#") { module.to_string() } else { format!("r#{module}") }; content.push_str(&format!("mod {mod_name};\n")); } content.push('\n'); let mut pub_use_parts: Vec = Vec::new(); for module in modules { let raw_name: &str = if let Some(stripped) = module.strip_prefix("r#") { stripped } else { module }; let mod_name: String = if module.starts_with("r#") { module.to_string() } else { format!("r#{module}") }; if raw_name == "const" || raw_name == "static" { pub_use_parts.push(mod_name); } else if raw_name == "enum" || raw_name == "fn" { pub_use_parts.push(format!("{mod_name}::*")); } else if raw_name == "struct" { pub_use_parts.push(mod_name); } } if !pub_use_parts.is_empty() { content.push_str("pub use {"); content.push_str(&pub_use_parts.join(", ")); content.push_str("};\n"); } content.push('\n'); content.push_str("use super::*;\n"); write(path, content)?; Ok(()) } fn write_empty_mod_rs(path: &Path) -> Result<(), TemplateError> { write(path, "\n")?; Ok(()) } fn create_controller_template( target_dir: &Path, _component_name: &str, ) -> Result<(), TemplateError> { ensure_directory(target_dir)?; let mod_rs: PathBuf = target_dir.join("mod.rs"); write_mod_rs(&mod_rs, &["fn", "impl", "struct"])?; let fn_rs: PathBuf = target_dir.join("fn.rs"); write(&fn_rs, "use super::*;\n")?; let impl_rs: PathBuf = target_dir.join("impl.rs"); write(&impl_rs, "use super::*;\n")?; let struct_rs: PathBuf = target_dir.join("struct.rs"); write(&struct_rs, "use super::*;\n")?; Ok(()) } fn create_view_template(target_dir: &Path, _component_name: &str) -> Result<(), TemplateError> { ensure_directory(target_dir)?; let mod_rs: PathBuf = target_dir.join("mod.rs"); write_mod_rs(&mod_rs, &["fn", "impl", "struct"])?; let fn_rs: PathBuf = target_dir.join("fn.rs"); write(&fn_rs, "use super::*;\n")?; let impl_rs: PathBuf = target_dir.join("impl.rs"); write(&impl_rs, "use super::*;\n")?; let struct_rs: PathBuf = target_dir.join("struct.rs"); write(&struct_rs, "use super::*;\n")?; Ok(()) } fn create_service_template(target_dir: &Path, _component_name: &str) -> Result<(), TemplateError> { ensure_directory(target_dir)?; let mod_rs: PathBuf = target_dir.join("mod.rs"); write_mod_rs(&mod_rs, &["impl", "struct"])?; let impl_rs: PathBuf = target_dir.join("impl.rs"); write(&impl_rs, "use super::*;\n")?; let struct_rs: PathBuf = target_dir.join("struct.rs"); write(&struct_rs, "use super::*;\n")?; Ok(()) } fn create_domain_template(target_dir: &Path, _component_name: &str) -> Result<(), TemplateError> { ensure_directory(target_dir)?; let mod_rs: PathBuf = target_dir.join("mod.rs"); write_mod_rs(&mod_rs, &["impl", "struct"])?; let impl_rs: PathBuf = target_dir.join("impl.rs"); write(&impl_rs, "use super::*;\n")?; let struct_rs: PathBuf = target_dir.join("struct.rs"); write(&struct_rs, "use super::*;\n")?; Ok(()) } fn create_mapper_template(target_dir: &Path, _component_name: &str) -> Result<(), TemplateError> { ensure_directory(target_dir)?; let mod_rs: PathBuf = target_dir.join("mod.rs"); write_mod_rs( &mod_rs, &["const", "enum", "fn", "impl", "static", "struct"], )?; let const_rs: PathBuf = target_dir.join("const.rs"); write(&const_rs, "use super::*;\n")?; let enum_rs: PathBuf = target_dir.join("enum.rs"); write(&enum_rs, "use super::*;\n")?; let fn_rs: PathBuf = target_dir.join("fn.rs"); write(&fn_rs, "use super::*;\n")?; let impl_rs: PathBuf = target_dir.join("impl.rs"); write(&impl_rs, "use super::*;\n")?; let static_rs: PathBuf = target_dir.join("static.rs"); write(&static_rs, "use super::*;\n")?; let struct_rs: PathBuf = target_dir.join("struct.rs"); write(&struct_rs, "use super::*;\n")?; Ok(()) } fn create_utils_template(target_dir: &Path, _component_name: &str) -> Result<(), TemplateError> { ensure_directory(target_dir)?; let mod_rs: PathBuf = target_dir.join("mod.rs"); write_mod_rs(&mod_rs, &["fn"])?; let fn_rs: PathBuf = target_dir.join("fn.rs"); write(&fn_rs, "use super::*;\n")?; Ok(()) } fn create_exception_template( target_dir: &Path, _component_name: &str, ) -> Result<(), TemplateError> { ensure_directory(target_dir)?; let mod_rs: PathBuf = target_dir.join("mod.rs"); write_empty_mod_rs(&mod_rs)?; Ok(()) } fn create_repository_template( target_dir: &Path, _component_name: &str, ) -> Result<(), TemplateError> { ensure_directory(target_dir)?; let mod_rs: PathBuf = target_dir.join("mod.rs"); write_mod_rs(&mod_rs, &["impl", "struct"])?; let impl_rs: PathBuf = target_dir.join("impl.rs"); write(&impl_rs, "use super::*;\n")?; let struct_rs: PathBuf = target_dir.join("struct.rs"); write(&struct_rs, "use super::*;\n")?; Ok(()) } fn create_model_template( target_dir: &Path, _component_name: &str, sub_type: &ModelSubType, ) -> Result<(), TemplateError> { let sub_type_name: String = get_model_sub_type_name(sub_type); let model_dir: PathBuf = target_dir.join(&sub_type_name); ensure_directory(&model_dir)?; let mod_rs: PathBuf = model_dir.join("mod.rs"); write_mod_rs(&mod_rs, &["struct"])?; let struct_rs: PathBuf = model_dir.join("struct.rs"); write(&struct_rs, "use super::*;\n")?; Ok(()) } pub(crate) async fn execute_template( template_type: TemplateType, component_name: &str, model_sub_type: Option, ) -> Result<(), TemplateError> { let config: TemplateConfig = TemplateConfig::new(template_type, component_name.to_string(), model_sub_type); let base_path: PathBuf = PathBuf::from(&config.base_directory); let dir_name: String = get_directory_name(&config.template_type); let type_dir: PathBuf = base_path.join(&dir_name); let target_dir: PathBuf = type_dir.join(&config.component_name); if target_dir.exists() { return Err(TemplateError::DirectoryExists( target_dir.to_string_lossy().to_string(), )); } ensure_directory(&type_dir)?; match config.template_type { TemplateType::Controller => { create_controller_template(&target_dir, &config.component_name)? } TemplateType::View => create_view_template(&target_dir, &config.component_name)?, TemplateType::Service => create_service_template(&target_dir, &config.component_name)?, TemplateType::Domain => create_domain_template(&target_dir, &config.component_name)?, TemplateType::Mapper => create_mapper_template(&target_dir, &config.component_name)?, TemplateType::Utils => create_utils_template(&target_dir, &config.component_name)?, TemplateType::Exception => create_exception_template(&target_dir, &config.component_name)?, TemplateType::Repository => { create_repository_template(&target_dir, &config.component_name)? } TemplateType::Model => { let sub_type: ModelSubType = config.model_sub_type.ok_or_else(|| { TemplateError::InvalidModelSubType("Missing model subtype".to_string()) })?; create_model_template(&target_dir, &config.component_name, &sub_type)?; } } let _: Result<(), std::io::Error> = crate::fmt::format_path(&target_dir).await; println!( "Created {} '{}' at {}", dir_name, config.component_name, target_dir.display() ); Ok(()) } ``` # Path: hyperlane-cli/src/template/impl.rs ```rust use crate::*; impl FromStr for TemplateType { type Err = TemplateError; fn from_str(s: &str) -> Result { match s.to_lowercase().as_str() { "controller" => Ok(Self::Controller), "domain" => Ok(Self::Domain), "exception" => Ok(Self::Exception), "mapper" => Ok(Self::Mapper), "model" => Ok(Self::Model), "repository" => Ok(Self::Repository), "service" => Ok(Self::Service), "utils" => Ok(Self::Utils), "view" => Ok(Self::View), _ => Err(TemplateError::InvalidTemplateType(s.to_string())), } } } impl TemplateConfig { pub(crate) fn new( template_type: TemplateType, component_name: String, model_sub_type: Option, ) -> Self { Self { template_type, component_name, model_sub_type, base_directory: "./application".to_string(), } } } impl FromStr for ModelSubType { type Err = TemplateError; fn from_str(s: &str) -> Result { match s.to_lowercase().as_str() { "application" => Ok(Self::Application), "request" => Ok(Self::Request), "response" => Ok(Self::Response), _ => Err(TemplateError::InvalidModelSubType(s.to_string())), } } } ``` # Path: hyperlane-cli/src/template/struct.rs ```rust use crate::*; #[derive(Clone, Debug)] pub(crate) struct TemplateConfig { pub template_type: TemplateType, pub component_name: String, pub model_sub_type: Option, pub base_directory: String, } ``` # Path: hyperlane-cli/src/template/test.rs ```rust use std::str::FromStr; use crate::*; #[test] fn test_template_config_new() { let config: TemplateConfig = TemplateConfig::new(TemplateType::Controller, "test".to_string(), None); assert_eq!(config.template_type, TemplateType::Controller); assert_eq!(config.component_name, "test"); assert_eq!(config.model_sub_type, None); assert_eq!(config.base_directory, "./application"); } #[test] fn test_template_config_with_model_sub_type() { let config: TemplateConfig = TemplateConfig::new( TemplateType::Model, "test".to_string(), Some(ModelSubType::Request), ); assert_eq!(config.template_type, TemplateType::Model); assert_eq!(config.model_sub_type, Some(ModelSubType::Request)); } #[test] fn test_template_config_clone() { let config: TemplateConfig = TemplateConfig::new(TemplateType::Service, "test".to_string(), None); let cloned: TemplateConfig = config.clone(); assert_eq!(cloned.template_type, config.template_type); assert_eq!(cloned.component_name, config.component_name); assert_eq!(cloned.model_sub_type, config.model_sub_type); assert_eq!(cloned.base_directory, config.base_directory); } #[test] fn test_template_config_debug() { let config: TemplateConfig = TemplateConfig::new(TemplateType::Controller, "test".to_string(), None); let debug_str: String = format!("{config:?}"); assert!(debug_str.contains("Controller")); assert!(debug_str.contains("test")); } #[test] fn test_template_error_display() { let error1: TemplateError = TemplateError::InvalidModelSubType("bad".to_string()); assert!(error1.to_string().contains("bad")); let error2: TemplateError = TemplateError::DirectoryExists("/path".to_string()); assert!(error2.to_string().contains("/path")); } #[test] fn test_template_error_from_io() { let io_error: std::io::Error = std::io::Error::new(std::io::ErrorKind::NotFound, "test"); let template_error: TemplateError = TemplateError::from(io_error); assert!(template_error.to_string().contains("IO error")); } #[test] fn test_template_error_debug() { let error: TemplateError = TemplateError::InvalidModelSubType("test".to_string()); let debug_str: String = format!("{error:?}"); assert!(debug_str.contains("InvalidModelSubType")); } #[test] fn test_template_type_equality() { assert_eq!(TemplateType::Controller, TemplateType::Controller); assert_ne!(TemplateType::Controller, TemplateType::Service); } #[test] fn test_model_sub_type_equality() { assert_eq!(ModelSubType::Request, ModelSubType::Request); assert_ne!(ModelSubType::Request, ModelSubType::Response); } #[test] fn test_template_type_debug() { let ty: TemplateType = TemplateType::Controller; let debug_str: String = format!("{ty:?}"); assert_eq!(debug_str, "Controller"); } #[test] fn test_model_sub_type_debug() { let ty: ModelSubType = ModelSubType::Application; let debug_str: String = format!("{ty:?}"); assert_eq!(debug_str, "Application"); } #[test] fn test_all_template_types() { let _ = TemplateType::Controller; let _ = TemplateType::Domain; let _ = TemplateType::Exception; let _ = TemplateType::Mapper; let _ = TemplateType::Model; let _ = TemplateType::Repository; let _ = TemplateType::Service; let _ = TemplateType::Utils; let _ = TemplateType::View; } #[test] fn test_all_model_sub_types() { let _ = ModelSubType::Application; let _ = ModelSubType::Request; let _ = ModelSubType::Response; } #[test] fn test_parse_template_type_valid() { assert_eq!( TemplateType::from_str("controller").ok(), Some(TemplateType::Controller) ); assert_eq!( TemplateType::from_str("Controller").ok(), Some(TemplateType::Controller) ); assert_eq!( TemplateType::from_str("CONTROLLER").ok(), Some(TemplateType::Controller) ); assert_eq!( TemplateType::from_str("domain").ok(), Some(TemplateType::Domain) ); assert_eq!( TemplateType::from_str("exception").ok(), Some(TemplateType::Exception) ); assert_eq!( TemplateType::from_str("mapper").ok(), Some(TemplateType::Mapper) ); assert_eq!( TemplateType::from_str("model").ok(), Some(TemplateType::Model) ); assert_eq!( TemplateType::from_str("repository").ok(), Some(TemplateType::Repository) ); assert_eq!( TemplateType::from_str("service").ok(), Some(TemplateType::Service) ); assert_eq!( TemplateType::from_str("utils").ok(), Some(TemplateType::Utils) ); assert_eq!( TemplateType::from_str("view").ok(), Some(TemplateType::View) ); } #[test] fn test_parse_template_type_invalid() { assert_eq!(TemplateType::from_str("invalid").ok(), None); assert_eq!(TemplateType::from_str("").ok(), None); assert_eq!(TemplateType::from_str("unknown").ok(), None); } #[test] fn test_parse_model_sub_type_valid() { assert_eq!( ModelSubType::from_str("application").ok(), Some(ModelSubType::Application) ); assert_eq!( ModelSubType::from_str("Application").ok(), Some(ModelSubType::Application) ); assert_eq!( ModelSubType::from_str("APPLICATION").ok(), Some(ModelSubType::Application) ); assert_eq!( ModelSubType::from_str("request").ok(), Some(ModelSubType::Request) ); assert_eq!( ModelSubType::from_str("response").ok(), Some(ModelSubType::Response) ); } #[test] fn test_parse_model_sub_type_invalid() { assert_eq!(ModelSubType::from_str("invalid").ok(), None); assert_eq!(ModelSubType::from_str("").ok(), None); assert_eq!(ModelSubType::from_str("unknown").ok(), None); } ``` # Path: hyperlane-cli/src/template/enum.rs ```rust #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub(crate) enum TemplateType { Controller, Domain, Exception, Mapper, Model, Repository, Service, Utils, View, } #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub(crate) enum ModelSubType { Application, Request, Response, } #[derive(Debug, thiserror::Error)] pub(crate) enum TemplateError { #[error("IO error: {0}")] IoError(#[from] std::io::Error), #[error("Invalid template type: {0}")] InvalidTemplateType(String), #[error("Invalid model subtype: {0}")] InvalidModelSubType(String), #[error("Directory '{0}' already exists")] DirectoryExists(String), } ``` # Path: hyperlane-cli/src/new/mod.rs ```rust mod r#enum; mod r#fn; mod r#impl; mod r#struct; #[cfg(test)] mod test; pub(crate) use {r#enum::*, r#fn::*, r#struct::*}; ``` # Path: hyperlane-cli/src/new/fn.rs ```rust use crate::*; fn validate_project_name(name: &str) -> Result<(), NewError> { if name.is_empty() { return Err(NewError::InvalidName( "Project name cannot be empty".to_string(), )); } if name.contains('/') || name.contains('\\') || name.contains(':') { return Err(NewError::InvalidName( "Project name contains invalid characters".to_string(), )); } if name.starts_with('.') || name.starts_with('-') { return Err(NewError::InvalidName( "Project name cannot start with '.' or '-'".to_string(), )); } Ok(()) } async fn check_git_available() -> Result<(), NewError> { let output: std::process::Output = Command::new("git") .arg("--version") .stdout(Stdio::null()) .stderr(Stdio::null()) .output() .await .map_err(|_| NewError::GitNotFound)?; if output.status.success() { Ok(()) } else { Err(NewError::GitNotFound) } } async fn git_clone(config: &NewProjectConfig) -> Result<(), NewError> { let project_path: PathBuf = PathBuf::from(&config.project_name); if project_path.exists() { return Err(NewError::ProjectExists(config.project_name.clone())); } let output: std::process::Output = Command::new("git") .arg("clone") .arg(&config.template_url) .arg(&config.project_name) .stdout(Stdio::piped()) .stderr(Stdio::piped()) .output() .await .map_err(NewError::IoError)?; if output.status.success() { Ok(()) } else { let stderr: String = String::from_utf8_lossy(&output.stderr).to_string(); Err(NewError::CloneFailed(stderr)) } } pub(crate) async fn execute_new(project_name: &str) -> Result<(), NewError> { validate_project_name(project_name)?; check_git_available().await?; let config: NewProjectConfig = NewProjectConfig::new(project_name.to_string()); println!( "Creating new project '{}' from template...", config.project_name ); git_clone(&config).await?; println!("Successfully created project '{}'", config.project_name); println!(" cd {}", config.project_name); println!(" cargo build"); Ok(()) } ``` # Path: hyperlane-cli/src/new/impl.rs ```rust use crate::*; impl NewProjectConfig { pub(crate) fn new(project_name: String) -> Self { Self { project_name, template_url: "https://github.com/hyperlane-dev/hyperlane-quick-start".to_string(), } } } ``` # Path: hyperlane-cli/src/new/struct.rs ```rust #[derive(Clone, Debug)] pub(crate) struct NewProjectConfig { pub project_name: String, pub template_url: String, } ``` # Path: hyperlane-cli/src/new/test.rs ```rust use crate::*; #[test] fn test_new_project_config_creation() { let config: NewProjectConfig = NewProjectConfig::new("test-project".to_string()); assert_eq!(config.project_name, "test-project"); assert_eq!( config.template_url, "https://github.com/hyperlane-dev/hyperlane-quick-start" ); } #[test] fn test_new_error_display() { let error1: NewError = NewError::GitNotFound; assert!(error1.to_string().contains("Git is not installed")); let error2: NewError = NewError::ProjectExists("test".to_string()); assert!(error2.to_string().contains("test")); let error3: NewError = NewError::CloneFailed("network error".to_string()); assert!(error3.to_string().contains("network error")); let error4: NewError = NewError::InvalidName("bad name".to_string()); assert!(error4.to_string().contains("bad name")); } #[test] fn test_new_error_from_io() { let io_error: std::io::Error = std::io::Error::new(std::io::ErrorKind::NotFound, "test"); let new_error: NewError = NewError::from(io_error); assert!(new_error.to_string().contains("test")); } #[test] fn test_new_error_debug() { let error: NewError = NewError::GitNotFound; let debug_str: String = format!("{error:?}"); assert!(debug_str.contains("GitNotFound")); } #[test] fn test_new_project_config_clone() { let config: NewProjectConfig = NewProjectConfig::new("test".to_string()); let cloned: NewProjectConfig = config.clone(); assert_eq!(cloned.project_name, config.project_name); assert_eq!(cloned.template_url, config.template_url); } #[test] fn test_new_project_config_debug() { let config: NewProjectConfig = NewProjectConfig::new("test".to_string()); let debug_str: String = format!("{config:?}"); assert!(debug_str.contains("test")); } ``` # Path: hyperlane-cli/src/new/enum.rs ```rust #[derive(Debug, thiserror::Error)] pub(crate) enum NewError { #[error("IO error: {0}")] IoError(#[from] std::io::Error), #[error("Git is not installed or not found in PATH")] GitNotFound, #[error("Project directory '{0}' already exists")] ProjectExists(String), #[error("Git clone failed: {0}")] CloneFailed(String), #[error("Invalid project name: {0}")] InvalidName(String), } ``` # Path: hyperlane-cli/src/config/mod.rs ```rust mod r#fn; mod r#struct; #[cfg(test)] mod test; pub(crate) use {r#fn::*, r#struct::*}; ``` # Path: hyperlane-cli/src/config/fn.rs ```rust use std::str::FromStr; use crate::*; pub(crate) fn parse_args() -> Args { let raw_args: Vec = args().collect(); let mut command: CommandType = CommandType::Help; let mut check: bool = false; let mut manifest_path: Option = None; let mut bump_type: Option = None; let mut max_retries: u32 = 3; let mut project_name: Option = None; let mut template_type: Option = None; let mut model_sub_type: Option = None; let mut component_name: Option = None; let mut i: usize = 1; while i < raw_args.len() { let arg: &str = raw_args[i].as_str(); match arg { "-h" | "--help" => { command = CommandType::Help; } "-v" | "--version" => { command = CommandType::Version; } "fmt" => { if command == CommandType::Help || command == CommandType::Version { command = CommandType::Fmt; } } "watch" => { if command == CommandType::Help || command == CommandType::Version { command = CommandType::Watch; } } "bump" => { if command == CommandType::Help || command == CommandType::Version { command = CommandType::Bump; } } "publish" => { if command == CommandType::Help || command == CommandType::Version { command = CommandType::Publish; } } "new" => { if command == CommandType::Help || command == CommandType::Version { command = CommandType::New; i += 1; if i < raw_args.len() && !raw_args[i].starts_with("--") && !raw_args[i].starts_with("-") { project_name = Some(raw_args[i].clone()); } else { i -= 1; } } } "template" => { if command == CommandType::Help || command == CommandType::Version { command = CommandType::Template; i += 1; if i < raw_args.len() && !raw_args[i].starts_with("--") && !raw_args[i].starts_with("-") { let type_str: &str = &raw_args[i]; template_type = TemplateType::from_str(type_str).ok(); i += 1; if template_type == Some(TemplateType::Model) && i < raw_args.len() && !raw_args[i].starts_with("--") && !raw_args[i].starts_with("-") { let sub_type_str: &str = &raw_args[i]; model_sub_type = ModelSubType::from_str(sub_type_str).ok(); i += 1; } if i < raw_args.len() && !raw_args[i].starts_with("--") && !raw_args[i].starts_with("-") { component_name = Some(raw_args[i].clone()); i += 1; } i -= 1; } } } "--patch" => { bump_type = Some(BumpVersionType::Patch); } "--minor" => { bump_type = Some(BumpVersionType::Minor); } "--major" => { bump_type = Some(BumpVersionType::Major); } "--release" => { bump_type = Some(BumpVersionType::Release); } "--alpha" => { bump_type = Some(BumpVersionType::Alpha); } "--beta" => { bump_type = Some(BumpVersionType::Beta); } "--rc" => { bump_type = Some(BumpVersionType::Rc); } "--check" => { check = true; } "--manifest-path" => { i += 1; if i < raw_args.len() { manifest_path = Some(raw_args[i].clone()); } } "--max-retries" => { i += 1; if i < raw_args.len() && let Ok(n) = raw_args[i].parse::() { max_retries = n; } } _ => {} } i += 1; } Args { command, check, manifest_path, bump_type, max_retries, project_name, template_type, model_sub_type, component_name, } } ``` # Path: hyperlane-cli/src/config/struct.rs ```rust use crate::*; #[derive(Clone, Debug)] pub struct Args { pub command: CommandType, pub check: bool, pub manifest_path: Option, pub bump_type: Option, pub max_retries: u32, pub project_name: Option, pub template_type: Option, pub model_sub_type: Option, pub component_name: Option, } ``` # Path: hyperlane-cli/src/config/test.rs ```rust use crate::*; #[test] fn test_args_default_values() { let args: Args = Args { command: CommandType::Help, check: false, manifest_path: None, bump_type: None, max_retries: 3, project_name: None, template_type: None, model_sub_type: None, component_name: None, }; assert!(!args.check); assert_eq!(args.max_retries, 3); assert!(args.manifest_path.is_none()); assert!(args.bump_type.is_none()); assert!(args.project_name.is_none()); assert!(args.template_type.is_none()); assert!(args.model_sub_type.is_none()); assert!(args.component_name.is_none()); } #[test] fn test_args_with_values() { let args: Args = Args { command: CommandType::Bump, check: true, manifest_path: Some("./test/Cargo.toml".to_string()), bump_type: Some(BumpVersionType::Minor), max_retries: 5, project_name: Some("test-project".to_string()), template_type: Some(TemplateType::Controller), model_sub_type: None, component_name: Some("test".to_string()), }; assert!(args.check); assert_eq!(args.max_retries, 5); assert_eq!(args.manifest_path, Some("./test/Cargo.toml".to_string())); assert_eq!(args.bump_type, Some(BumpVersionType::Minor)); assert_eq!(args.project_name, Some("test-project".to_string())); assert_eq!(args.template_type, Some(TemplateType::Controller)); assert_eq!(args.component_name, Some("test".to_string())); } #[test] fn test_args_with_model_subtype() { let args: Args = Args { command: CommandType::Template, check: false, manifest_path: None, bump_type: None, max_retries: 3, project_name: None, template_type: Some(TemplateType::Model), model_sub_type: Some(ModelSubType::Request), component_name: Some("user".to_string()), }; assert_eq!(args.template_type, Some(TemplateType::Model)); assert_eq!(args.model_sub_type, Some(ModelSubType::Request)); assert_eq!(args.component_name, Some("user".to_string())); } #[test] fn test_command_type_enum_values() { let _: CommandType = CommandType::Fmt; let _: CommandType = CommandType::Watch; let _: CommandType = CommandType::Bump; let _: CommandType = CommandType::Publish; let _: CommandType = CommandType::New; let _: CommandType = CommandType::Template; let _: CommandType = CommandType::Help; let _: CommandType = CommandType::Version; } #[test] fn test_args_clone() { let args: Args = Args { command: CommandType::Bump, check: true, manifest_path: Some("./test/Cargo.toml".to_string()), bump_type: Some(BumpVersionType::Minor), max_retries: 5, project_name: Some("test-project".to_string()), template_type: Some(TemplateType::Controller), model_sub_type: None, component_name: Some("test".to_string()), }; let cloned: Args = args.clone(); assert_eq!(cloned.check, args.check); assert_eq!(cloned.max_retries, args.max_retries); assert_eq!(cloned.manifest_path, args.manifest_path); assert_eq!(cloned.bump_type, args.bump_type); assert_eq!(cloned.project_name, args.project_name); assert_eq!(cloned.template_type, args.template_type); assert_eq!(cloned.component_name, args.component_name); } ``` # Path: hyperlane-cli/src/bump/mod.rs ```rust mod r#enum; mod r#fn; mod r#struct; #[cfg(test)] mod test; pub(crate) use {r#enum::*, r#fn::*, r#struct::*}; ``` # Path: hyperlane-cli/src/bump/fn.rs ```rust use crate::*; fn parse_version(version_str: &str) -> Option { let parts: Vec<&str> = version_str.split('-').collect(); let version_part: &str = parts.first()?; let prerelease: Option = parts.get(1).map(|s: &&str| s.to_string()); let nums: Vec<&str> = version_part.split('.').collect(); if nums.len() != 3 { return None; } let major: u64 = nums.first()?.parse().ok()?; let minor: u64 = nums.get(1)?.parse().ok()?; let patch: u64 = nums.get(2)?.parse().ok()?; Some(Version { major, minor, patch, prerelease, }) } fn parse_prerelease(prerelease: &str) -> Option<(&str, u64)> { let parts: Vec<&str> = prerelease.split('.').collect(); let pre_type: &str = parts.first()?; let number: u64 = parts .get(1) .and_then(|s: &&str| s.parse().ok()) .unwrap_or(0); Some((pre_type, number)) } fn get_next_prerelease(current: Option<&String>, target_type: &str) -> String { match current { Some(pre) => { if let Some((pre_type, number)) = parse_prerelease(pre) && pre_type == target_type && number > 0 { return format!("{}.{}", target_type, number + 1); } format!("{target_type}.1") } None => target_type.to_string(), } } fn version_to_string(version: &Version) -> String { let base: String = format!("{}.{}.{}", version.major, version.minor, version.patch); match &version.prerelease { Some(pre) => format!("{base}-{pre}"), None => base, } } fn bump_version(version: &Version, bump_type: &BumpVersionType) -> Version { match bump_type { BumpVersionType::Patch => Version { major: version.major, minor: version.minor, patch: version.patch + 1, prerelease: None, }, BumpVersionType::Minor => Version { major: version.major, minor: version.minor + 1, patch: 0, prerelease: None, }, BumpVersionType::Major => Version { major: version.major + 1, minor: 0, patch: 0, prerelease: None, }, BumpVersionType::Release => Version { major: version.major, minor: version.minor, patch: version.patch, prerelease: None, }, BumpVersionType::Alpha => { let prerelease: String = get_next_prerelease(version.prerelease.as_ref(), "alpha"); Version { major: version.major, minor: version.minor, patch: version.patch, prerelease: Some(prerelease), } } BumpVersionType::Beta => { let prerelease: String = get_next_prerelease(version.prerelease.as_ref(), "beta"); Version { major: version.major, minor: version.minor, patch: version.patch, prerelease: Some(prerelease), } } BumpVersionType::Rc => { let prerelease: String = get_next_prerelease(version.prerelease.as_ref(), "rc"); Version { major: version.major, minor: version.minor, patch: version.patch, prerelease: Some(prerelease), } } } } fn find_version_position(line: &str) -> Option<(usize, usize)> { let trimmed: &str = line.trim(); if !trimmed.starts_with("version") || !trimmed.contains('=') { return None; } let eq_pos: usize = line.find('=')?; let after_eq: &str = &line[eq_pos + 1..]; let quote_start: usize = after_eq.find('"')?; let after_first_quote: &str = &after_eq[quote_start + 1..]; let quote_end: usize = after_first_quote.find('"')?; let version_start: usize = eq_pos + 1 + quote_start + 1; let version_end: usize = version_start + quote_end; Some((version_start, version_end)) } pub(crate) fn execute_bump( manifest_path: &str, bump_type: &BumpVersionType, ) -> Result> { let path: &Path = Path::new(manifest_path); let content: String = read_to_string(path)?; let mut new_version: Option = None; let mut found_version: bool = false; let mut updated_content: String = content.clone(); for line in content.lines() { if found_version { break; } if let Some((version_start, version_end)) = find_version_position(line) { let version_str: &str = &line[version_start..version_end]; if let Some(version) = parse_version(version_str) { let bumped: Version = bump_version(&version, bump_type); let version_string: String = version_to_string(&bumped); new_version = Some(version_string.clone()); let new_line: String = format!( "{}{}{}", &line[..version_start], version_string, &line[version_end..] ); updated_content = updated_content.replacen(line, &new_line, 1); found_version = true; } } } if !found_version { return Err("version field not found in Cargo.toml".into()); } write(path, updated_content)?; match new_version { Some(v) => Ok(v), None => Err("failed to bump version".into()), } } ``` # Path: hyperlane-cli/src/bump/struct.rs ```rust #[derive(Clone, Debug, Eq, PartialEq)] pub(crate) struct Version { pub major: u64, pub minor: u64, pub patch: u64, pub prerelease: Option, } ``` # Path: hyperlane-cli/src/bump/test.rs ```rust use crate::*; #[test] fn test_bump_version_type_enum() { assert_eq!(BumpVersionType::Patch, BumpVersionType::Patch); assert_eq!(BumpVersionType::Minor, BumpVersionType::Minor); assert_eq!(BumpVersionType::Major, BumpVersionType::Major); assert_eq!(BumpVersionType::Release, BumpVersionType::Release); assert_eq!(BumpVersionType::Alpha, BumpVersionType::Alpha); assert_eq!(BumpVersionType::Beta, BumpVersionType::Beta); assert_eq!(BumpVersionType::Rc, BumpVersionType::Rc); } #[test] fn test_version_struct_creation() { let version: Version = Version { major: 1, minor: 2, patch: 3, prerelease: Some("alpha.1".to_string()), }; assert_eq!(version.major, 1); assert_eq!(version.minor, 2); assert_eq!(version.patch, 3); assert_eq!(version.prerelease, Some("alpha.1".to_string())); } #[test] fn test_version_clone() { let version: Version = Version { major: 1, minor: 2, patch: 3, prerelease: Some("beta".to_string()), }; let cloned: Version = version.clone(); assert_eq!(cloned.major, version.major); assert_eq!(cloned.minor, version.minor); assert_eq!(cloned.patch, version.patch); assert_eq!(cloned.prerelease, version.prerelease); } #[test] fn test_execute_bump_integration() { use std::fs::write; use std::path::PathBuf; let tmp_dir: PathBuf = PathBuf::from("./tmp/test_bump"); let _ = std::fs::create_dir_all(&tmp_dir); let manifest_path: PathBuf = tmp_dir.join("Cargo.toml"); let content: &str = r#"[package] name = "test-package" version = "0.1.0" edition = "2024" "#; write(&manifest_path, content).unwrap(); let result: Result> = execute_bump(manifest_path.to_str().unwrap(), &BumpVersionType::Patch); assert!(result.is_ok()); assert_eq!(result.unwrap(), "0.1.1"); let updated_content: String = std::fs::read_to_string(&manifest_path).unwrap(); assert!(updated_content.contains("version = \"0.1.1\"")); } #[test] fn test_execute_bump_minor() { use std::fs::write; use std::path::PathBuf; let tmp_dir: PathBuf = PathBuf::from("./tmp/test_bump_minor"); let _ = std::fs::create_dir_all(&tmp_dir); let manifest_path: PathBuf = tmp_dir.join("Cargo.toml"); let content: &str = r#"[package] name = "test-package" version = "0.1.0" edition = "2024" "#; write(&manifest_path, content).unwrap(); let result: Result> = execute_bump(manifest_path.to_str().unwrap(), &BumpVersionType::Minor); assert!(result.is_ok()); assert_eq!(result.unwrap(), "0.2.0"); } #[test] fn test_execute_bump_major() { use std::fs::write; use std::path::PathBuf; let tmp_dir: PathBuf = PathBuf::from("./tmp/test_bump_major"); let _ = std::fs::create_dir_all(&tmp_dir); let manifest_path: PathBuf = tmp_dir.join("Cargo.toml"); let content: &str = r#"[package] name = "test-package" version = "0.1.0" edition = "2024" "#; write(&manifest_path, content).unwrap(); let result: Result> = execute_bump(manifest_path.to_str().unwrap(), &BumpVersionType::Major); assert!(result.is_ok()); assert_eq!(result.unwrap(), "1.0.0"); } #[test] fn test_execute_bump_alpha() { use std::fs::write; use std::path::PathBuf; let tmp_dir: PathBuf = PathBuf::from("./tmp/test_bump_alpha"); let _ = std::fs::create_dir_all(&tmp_dir); let manifest_path: PathBuf = tmp_dir.join("Cargo.toml"); let content: &str = r#"[package] name = "test-package" version = "0.1.0" edition = "2024" "#; write(&manifest_path, content).unwrap(); let result: Result> = execute_bump(manifest_path.to_str().unwrap(), &BumpVersionType::Alpha); assert!(result.is_ok()); assert_eq!(result.unwrap(), "0.1.0-alpha"); } #[test] fn test_execute_bump_beta() { use std::fs::write; use std::path::PathBuf; let tmp_dir: PathBuf = PathBuf::from("./tmp/test_bump_beta"); let _ = std::fs::create_dir_all(&tmp_dir); let manifest_path: PathBuf = tmp_dir.join("Cargo.toml"); let content: &str = r#"[package] name = "test-package" version = "0.1.0-alpha.2" edition = "2024" "#; write(&manifest_path, content).unwrap(); let result: Result> = execute_bump(manifest_path.to_str().unwrap(), &BumpVersionType::Beta); assert!(result.is_ok()); assert_eq!(result.unwrap(), "0.1.0-beta.1"); } #[test] fn test_execute_bump_rc() { use std::fs::write; use std::path::PathBuf; let tmp_dir: PathBuf = PathBuf::from("./tmp/test_bump_rc"); let _ = std::fs::create_dir_all(&tmp_dir); let manifest_path: PathBuf = tmp_dir.join("Cargo.toml"); let content: &str = r#"[package] name = "test-package" version = "0.1.0-beta.1" edition = "2024" "#; write(&manifest_path, content).unwrap(); let result: Result> = execute_bump(manifest_path.to_str().unwrap(), &BumpVersionType::Rc); assert!(result.is_ok()); assert_eq!(result.unwrap(), "0.1.0-rc.1"); } #[test] fn test_execute_bump_release() { use std::fs::write; use std::path::PathBuf; let tmp_dir: PathBuf = PathBuf::from("./tmp/test_bump_release"); let _ = std::fs::create_dir_all(&tmp_dir); let manifest_path: PathBuf = tmp_dir.join("Cargo.toml"); let content: &str = r#"[package] name = "test-package" version = "0.1.0-alpha" edition = "2024" "#; write(&manifest_path, content).unwrap(); let result: Result> = execute_bump(manifest_path.to_str().unwrap(), &BumpVersionType::Release); assert!(result.is_ok()); assert_eq!(result.unwrap(), "0.1.0"); } #[test] fn test_execute_bump_no_version_field() { use std::fs::write; use std::path::PathBuf; let tmp_dir: PathBuf = PathBuf::from("./tmp/test_bump_no_version"); let _ = std::fs::create_dir_all(&tmp_dir); let manifest_path: PathBuf = tmp_dir.join("Cargo.toml"); let content: &str = r#"[package] name = "test-package" edition = "2024" "#; write(&manifest_path, content).unwrap(); let result: Result> = execute_bump(manifest_path.to_str().unwrap(), &BumpVersionType::Patch); assert!(result.is_err()); } ``` # Path: hyperlane-cli/src/bump/enum.rs ```rust #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub(crate) enum BumpVersionType { Patch, Minor, Major, Release, Alpha, Beta, Rc, } ``` # Path: hyperlane-cli/src/publish/mod.rs ```rust mod r#enum; mod r#fn; mod r#struct; #[cfg(test)] mod test; pub(crate) use {r#enum::*, r#fn::*, r#struct::*}; ``` # Path: hyperlane-cli/src/publish/fn.rs ```rust use crate::*; fn discover_packages(workspace_root: &Path) -> Result, PublishError> { let content: String = read_to_string(workspace_root)?; let doc: toml::Value = toml::from_str(&content).map_err(|_| PublishError::ManifestParseError)?; let mut packages: Vec = Vec::new(); if let Some(workspace) = doc.get("workspace") && let Some(members) = workspace.get("members").and_then(|m| m.as_array()) { for member in members { if let Some(pattern) = member.as_str() { let base_path: &Path = workspace_root.parent().unwrap_or(workspace_root); expand_pattern(base_path, pattern, &mut packages)?; } } } if packages.is_empty() { let package: Package = read_single_package(workspace_root)?; packages.push(package); } Ok(packages) } fn expand_pattern( base_path: &Path, pattern: &str, packages: &mut Vec, ) -> Result<(), PublishError> { if pattern.contains('*') { let parent: &Path = Path::new(pattern).parent().unwrap_or(Path::new(".")); let full_parent: PathBuf = base_path.join(parent); if full_parent.is_dir() { for entry in std::fs::read_dir(&full_parent)? { let entry: std::fs::DirEntry = entry?; let path: PathBuf = entry.path(); if path.is_dir() { let cargo_toml: PathBuf = path.join("Cargo.toml"); if cargo_toml.exists() { let package: Package = read_package_manifest(&cargo_toml)?; packages.push(package); } } } } } else { let cargo_toml: PathBuf = base_path.join(pattern).join("Cargo.toml"); if cargo_toml.exists() { let package: Package = read_package_manifest(&cargo_toml)?; packages.push(package); } } Ok(()) } fn read_single_package(manifest_path: &Path) -> Result { read_package_manifest(manifest_path) } fn read_package_manifest(manifest_path: &Path) -> Result { let content: String = read_to_string(manifest_path)?; let doc: toml::Value = toml::from_str(&content).map_err(|_| PublishError::ManifestParseError)?; let package_table: &toml::Value = doc.get("package").ok_or(PublishError::ManifestParseError)?; let name: String = package_table .get("name") .and_then(|n: &toml::Value| n.as_str()) .ok_or(PublishError::ManifestParseError)? .to_string(); let version: String = package_table .get("version") .and_then(|v: &toml::Value| v.as_str()) .ok_or(PublishError::ManifestParseError)? .to_string(); let path: PathBuf = manifest_path .parent() .filter(|p: &&Path| !p.as_os_str().is_empty()) .map_or_else(|| PathBuf::from("."), |p: &Path| p.to_path_buf()); let local_dependencies: Vec = extract_local_dependencies(&doc, manifest_path)?; Ok(Package { name, version, path, local_dependencies, }) } fn extract_local_dependencies( doc: &toml::Value, _manifest_path: &Path, ) -> Result, PublishError> { let mut deps: Vec = Vec::new(); let dep_sections: [&str; 3] = ["dependencies", "dev-dependencies", "build-dependencies"]; for section in &dep_sections { if let Some(table) = doc.get(section).and_then(|s| s.as_table()) { for (dep_name, dep_value) in table { let is_local: bool = match dep_value { toml::Value::Table(t) => { t.get("path").is_some() || t.get("workspace") .and_then(|w| w.as_bool()) .unwrap_or(false) } _ => false, }; if is_local { deps.push(dep_name.clone()); } } } } Ok(deps) } fn topological_sort(packages: &[Package]) -> Result, PublishError> { let mut in_degree: HashMap = HashMap::new(); let mut graph: HashMap> = HashMap::new(); let package_map: HashMap = packages .iter() .map(|p| (p.name.clone(), p.clone())) .collect(); for package in packages { in_degree.entry(package.name.clone()).or_insert(0); for dep in &package.local_dependencies { if package_map.contains_key(dep) { graph .entry(dep.clone()) .or_default() .push(package.name.clone()); *in_degree.entry(package.name.clone()).or_insert(0) += 1; } } } let mut queue: VecDeque = VecDeque::new(); for (name, degree) in &in_degree { if *degree == 0 { queue.push_back(name.clone()); } } let mut result: Vec = Vec::new(); while let Some(name) = queue.pop_front() { if let Some(package) = package_map.get(&name) { result.push(package.clone()); } if let Some(dependents) = graph.get(&name) { for dependent in dependents { if let Some(degree) = in_degree.get_mut(dependent) { *degree -= 1; if *degree == 0 { queue.push_back(dependent.clone()); } } } } } if result.len() != packages.len() { return Err(PublishError::CircularDependency); } Ok(result) } async fn publish_package_with_retry(package: &Package, max_retries: u32) -> PublishResult { let mut attempt: u32 = 0; let mut last_error: Option = None; while attempt <= max_retries { match publish_single_package(package).await { Ok(()) => { return PublishResult { package_name: package.name.clone(), success: true, error: None, retries: attempt, }; } Err(error) => { last_error = Some(error.to_string()); attempt += 1; if attempt <= max_retries { tokio::time::sleep(tokio::time::Duration::from_secs(2_u64.pow(attempt))).await; } } } } PublishResult { package_name: package.name.clone(), success: false, error: last_error, retries: attempt - 1, } } async fn publish_single_package(package: &Package) -> Result<(), Box> { let output: std::process::Output = Command::new("cargo") .arg("publish") .arg("--allow-dirty") .current_dir(&package.path) .stdout(Stdio::piped()) .stderr(Stdio::piped()) .output() .await?; if output.status.success() { Ok(()) } else { let stderr: String = String::from_utf8_lossy(&output.stderr).to_string(); Err(stderr.into()) } } pub(crate) async fn execute_publish( manifest_path: &str, max_retries: u32, ) -> Result, PublishError> { let path: &Path = Path::new(manifest_path); let packages: Vec = discover_packages(path)?; if packages.is_empty() { return Ok(Vec::new()); } let sorted_packages: Vec = topological_sort(&packages)?; let mut results: Vec = Vec::new(); for package in sorted_packages { println!("Publishing {} v{}...", package.name, package.version); let result: PublishResult = publish_package_with_retry(&package, max_retries).await; if result.success { if result.retries == 0 { println!("Successfully published {}", result.package_name,); } else { println!( "Successfully published {} (retried {} times)", result.package_name, result.retries ); } } else if let Some(error) = &result.error { eprintln!("Failed to publish {}: {error}", result.package_name); } else { eprintln!("Failed to publish {}", result.package_name); } results.push(result); } Ok(results) } ``` # Path: hyperlane-cli/src/publish/struct.rs ```rust #[derive(Clone, Debug, Eq, PartialEq)] pub(crate) struct Package { pub name: String, pub version: String, pub path: std::path::PathBuf, pub local_dependencies: Vec, } #[derive(Clone, Debug)] pub(crate) struct PublishResult { pub package_name: String, pub success: bool, pub error: Option, pub retries: u32, } ``` # Path: hyperlane-cli/src/publish/test.rs ```rust use crate::*; #[test] fn test_package_creation() { let package: Package = Package { name: "test-package".to_string(), version: "0.1.0".to_string(), path: std::path::PathBuf::from("."), local_dependencies: vec![], }; assert_eq!(package.name, "test-package"); assert_eq!(package.version, "0.1.0"); assert!(package.local_dependencies.is_empty()); } #[test] fn test_package_clone() { let package: Package = Package { name: "test-package".to_string(), version: "0.1.0".to_string(), path: std::path::PathBuf::from("."), local_dependencies: vec!["dep1".to_string()], }; let cloned: Package = package.clone(); assert_eq!(cloned.name, package.name); assert_eq!(cloned.version, package.version); assert_eq!(cloned.local_dependencies.len(), 1); } #[test] fn test_package_equality() { let package1: Package = Package { name: "test".to_string(), version: "0.1.0".to_string(), path: std::path::PathBuf::from("."), local_dependencies: vec![], }; let package2: Package = Package { name: "test".to_string(), version: "0.1.0".to_string(), path: std::path::PathBuf::from("."), local_dependencies: vec![], }; assert_eq!(package1, package2); } #[test] fn test_publish_result_success() { let result: PublishResult = PublishResult { package_name: "test".to_string(), success: true, error: None, retries: 0, }; assert_eq!(result.package_name, "test"); assert!(result.success); assert!(result.error.is_none()); assert_eq!(result.retries, 0); } #[test] fn test_publish_result_failure() { let result: PublishResult = PublishResult { package_name: "test".to_string(), success: false, error: Some("network error".to_string()), retries: 3, }; assert!(!result.success); assert_eq!(result.error, Some("network error".to_string())); assert_eq!(result.retries, 3); } #[test] fn test_publish_result_clone() { let result: PublishResult = PublishResult { package_name: "test".to_string(), success: true, error: None, retries: 0, }; let cloned: PublishResult = result.clone(); assert_eq!(cloned.package_name, result.package_name); assert_eq!(cloned.success, result.success); assert_eq!(cloned.error, result.error); assert_eq!(cloned.retries, result.retries); } #[test] fn test_publish_error_display() { let error1: PublishError = PublishError::ManifestParseError; assert!(error1.to_string().contains("Failed to parse")); let error2: PublishError = PublishError::CircularDependency; assert!(error2.to_string().contains("Circular dependency")); } #[test] fn test_publish_error_from_io() { let io_error: std::io::Error = std::io::Error::new(std::io::ErrorKind::NotFound, "test"); let publish_error: PublishError = PublishError::from(io_error); assert!(publish_error.to_string().contains("IO error")); } ``` # Path: hyperlane-cli/src/publish/enum.rs ```rust #[derive(Debug, thiserror::Error)] pub(crate) enum PublishError { #[error("Failed to parse Cargo.toml")] ManifestParseError, #[error("Circular dependency detected")] CircularDependency, #[error("IO error: {0}")] IoError(#[from] std::io::Error), } ``` # Path: hyperlane-cli/src/help/mod.rs ```rust mod r#fn; pub(crate) use r#fn::*; ``` # Path: hyperlane-cli/src/help/fn.rs ```rust pub(crate) fn print_help() { println!("hyperlane-cli [COMMAND] [OPTIONS]"); println!(); println!("Commands:"); println!(" bump Bump version in Cargo.toml"); println!(" fmt Format Rust code using cargo fmt"); println!(" watch Watch files and run cargo run using cargo-watch"); println!(" publish Publish packages in monorepo with topological ordering"); println!(" new Create a new project from template"); println!( " template Generate template components (controller|domain|exception|mapper|model|repository|service|utils|view)" ); println!(" -h, --help Print this help message"); println!(" -v, --version Print version information"); println!(); println!("New Options:"); println!(" Name of the project to create"); println!(); println!("Bump Options:"); println!(" --patch Bump patch version (0.1.0 -> 0.1.1) [default]"); println!(" --minor Bump minor version (0.1.0 -> 0.2.0)"); println!(" --major Bump major version (0.1.0 -> 1.0.0)"); println!( " --alpha Add or bump alpha version (0.1.0 -> 0.1.0-alpha, 0.1.0-alpha -> 0.1.0-alpha.1)" ); println!( " --beta Add or bump beta version (0.1.0 -> 0.1.0-beta, 0.1.0-alpha.2 -> 0.1.0-beta.1)" ); println!( " --rc Add or bump rc version (0.1.0 -> 0.1.0-rc, 0.1.0-beta.1 -> 0.1.0-rc.1)" ); println!(" --release Remove pre-release identifier (0.1.0-alpha -> 0.1.0)"); println!(" --manifest-path Path to Cargo.toml [default: Cargo.toml]"); println!(); println!("Fmt Options:"); println!(" --check Check formatting without making changes"); println!(" --manifest-path Path to Cargo.toml"); println!(); println!("Publish Options:"); println!(" --manifest-path Path to workspace Cargo.toml [default: Cargo.toml]"); println!(" --max-retries Maximum retry attempts per package [default: 3]"); } ``` # Path: hyperlane-cli/src/watch/mod.rs ```rust mod r#fn; pub(crate) use r#fn::*; ``` # Path: hyperlane-cli/src/watch/fn.rs ```rust use crate::*; async fn is_cargo_watch_installed() -> bool { Command::new("cargo-watch") .arg("--version") .stdout(Stdio::null()) .stderr(Stdio::null()) .status() .await .is_ok_and(|status: ExitStatus| status.success()) } async fn install_cargo_watch() -> Result<(), std::io::Error> { println!("cargo-watch not found, installing..."); let mut cmd: Command = Command::new("cargo"); cmd.arg("install").arg("cargo-watch"); cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit()); let status: ExitStatus = cmd.status().await?; if !status.success() { return Err(std::io::Error::other("failed to install cargo-watch")); } Ok(()) } pub(crate) async fn execute_watch() -> Result<(), std::io::Error> { if !is_cargo_watch_installed().await { install_cargo_watch().await?; } let mut cmd: Command = Command::new("cargo-watch"); cmd.arg("--clear") .arg("--skip-local-deps") .arg("-q") .arg("-x") .arg("run"); cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit()); let status: ExitStatus = cmd.status().await?; if !status.success() { return Err(std::io::Error::other("cargo-watch failed")); } Ok(()) } ``` # Path: hyperlane-cli/src/command/mod.rs ```rust mod r#enum; pub(crate) use r#enum::*; ``` # Path: hyperlane-cli/src/command/enum.rs ```rust #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub(crate) enum CommandType { Fmt, Watch, Bump, Publish, New, Template, Help, Version, } ``` # Path: hyperlane-cli/src/version/mod.rs ```rust mod r#fn; #[cfg(test)] mod test; pub(crate) use r#fn::*; ``` # Path: hyperlane-cli/src/version/fn.rs ```rust pub(crate) fn print_version() { println!("hyperlane-cli {}", env!("CARGO_PKG_VERSION")); } ``` # Path: hyperlane-cli/src/version/test.rs ```rust use crate::*; #[test] fn test_print_version_runs() { print_version(); } ``` # Path: hyperlane-log/README.md ## hyperlane-log [Official Documentation](https://docs.ltpp.vip/hyperlane-log/) [Api Docs](https://docs.rs/hyperlane-log/latest/) > A Rust logging library that supports both asynchronous and synchronous logging. It provides multiple log levels, such as error, info, and debug. Users can define custom log handling methods and configure log file paths. The library supports log rotation, automatically creating a new log file when the current file reaches the specified size limit. It allows flexible logging configurations, making it suitable for both high-performance asynchronous applications and traditional synchronous logging scenarios. The asynchronous mode utilizes Tokio's async channels for efficient log buffering, while the synchronous mode writes logs directly to the file system. ## Installation To use this crate, you can run cmd: ```shell cargo add hyperlane-log ``` ## Log Storage Location Description > Three directories will be created under the user-specified directory: one for error logs, one for info logs, and one for debug logs. Each of these directories will contain a subdirectory named by the date, and the log files within these subdirectories will be named in the format `timestamp.index.log`. ## Contact # Path: hyperlane-log/src/const.rs ```rust pub const DEFAULT_LOG_DIR: &str = "./logs"; pub const LOG_EXTENSION: &str = "log"; pub const DEFAULT_LOG_FILE_START_IDX: usize = 1; pub const DEFAULT_LOG_FILE_SIZE: usize = 1_024_000_000; pub const DISABLE_LOG_FILE_SIZE: usize = 0; pub(crate) const ROOT_PATH: &str = "/"; pub(crate) const POINT: &str = "."; pub(crate) const BR: &str = "\n"; pub const TRACE_DIR: &str = "trace"; pub const DEBUG_DIR: &str = "debug"; pub const INFO_DIR: &str = "info"; pub const WARN_DIR: &str = "warn"; pub const ERROR_DIR: &str = "error"; ``` # Path: hyperlane-log/src/lib.rs ```rust mod r#const; mod r#fn; mod r#impl; mod r#struct; #[cfg(test)] mod test; mod r#trait; pub use {r#const::*, r#fn::*, r#struct::*, r#trait::*}; use std::fs::read_dir; use {file_operation::*, hyperlane_time::*}; ``` # Path: hyperlane-log/src/trait.rs ```rust pub trait FileLoggerFuncTrait>: Fn(T) -> String + Send + Sync {} ``` # Path: hyperlane-log/src/fn.rs ```rust use crate::*; pub(crate) fn get_second_element_from_filename(dir_path: &str) -> usize { let mut res_idx: usize = DEFAULT_LOG_FILE_START_IDX; if let Ok(entries) = read_dir(dir_path) { for entry in entries.filter_map(Result::ok) { let file_name: String = entry.file_name().to_string_lossy().to_string(); let parts: Vec<&str> = file_name.split(POINT).collect(); if parts.len() > 1 && let Ok(second_element) = parts[1].parse::() { res_idx = second_element.max(res_idx); } } } res_idx.max(DEFAULT_LOG_FILE_START_IDX) } #[inline(always)] pub(crate) fn get_file_name(idx: usize) -> String { format!( "{}{}{}{}{}{}", ROOT_PATH, date(), POINT, idx, POINT, LOG_EXTENSION ) } #[inline(always)] pub(crate) fn get_file_dir_name() -> String { format!("{}{}", ROOT_PATH, date()) } pub(crate) fn get_log_path(system_dir: &str, base_path: &str, limit_file_size: &usize) -> String { let mut combined_path: String = base_path.trim_end_matches(ROOT_PATH).to_string(); if !system_dir.starts_with(ROOT_PATH) { combined_path.push_str(ROOT_PATH); } combined_path.push_str( system_dir .trim_start_matches(ROOT_PATH) .trim_end_matches(ROOT_PATH), ); combined_path.push_str(&get_file_dir_name()); let idx: usize = get_second_element_from_filename(&combined_path); let mut combined_path_clone: String = combined_path.clone(); combined_path.push_str(&get_file_name(idx)); let file_size: usize = get_file_size(&combined_path).unwrap_or_default() as usize; if &file_size <= limit_file_size { return combined_path; } combined_path_clone.push_str(&get_file_name(idx + 1)); combined_path_clone } #[inline(always)] pub fn common_log>(data: T) -> String { let mut log_string: String = String::new(); for line in data.as_ref().lines() { let line_string: String = format!("{} {}{}", time(), line, BR); log_string.push_str(&line_string); } log_string } #[inline(always)] pub fn log_handler>(log_data: T) -> String { common_log(log_data) } ``` # Path: hyperlane-log/src/impl.rs ```rust use crate::*; impl FileLoggerFuncTrait for F where F: Fn(T) -> String + Send + Sync, T: AsRef, { } impl Default for FileLogger { #[inline(always)] fn default() -> Self { Self { path: DEFAULT_LOG_DIR.to_owned(), limit_file_size: DEFAULT_LOG_FILE_SIZE, trace_dir: TRACE_DIR.to_owned(), debug_dir: DEBUG_DIR.to_owned(), info_dir: INFO_DIR.to_owned(), warn_dir: WARN_DIR.to_owned(), error_dir: ERROR_DIR.to_owned(), } } } impl FileLogger { #[inline(always)] pub fn new>(path: P, limit_file_size: usize) -> Self { Self { path: path.as_ref().to_owned(), limit_file_size, trace_dir: TRACE_DIR.to_owned(), debug_dir: DEBUG_DIR.to_owned(), info_dir: INFO_DIR.to_owned(), warn_dir: WARN_DIR.to_owned(), error_dir: ERROR_DIR.to_owned(), } } #[inline(always)] pub fn get_path(&self) -> &String { &self.path } #[inline(always)] pub fn get_limit_file_size(&self) -> &usize { &self.limit_file_size } #[inline(always)] pub fn get_trace_dir(&self) -> &String { &self.trace_dir } #[inline(always)] pub fn get_debug_dir(&self) -> &String { &self.debug_dir } #[inline(always)] pub fn get_info_dir(&self) -> &String { &self.info_dir } #[inline(always)] pub fn get_warn_dir(&self) -> &String { &self.warn_dir } #[inline(always)] pub fn get_error_dir(&self) -> &String { &self.error_dir } #[inline(always)] pub fn set_path>(&mut self, path: P) -> &mut Self { self.path = path.as_ref().to_owned(); self } #[inline(always)] pub fn set_limit_file_size(&mut self, limit_file_size: usize) -> &mut Self { self.limit_file_size = limit_file_size; self } #[inline(always)] pub fn set_trace_dir>(&mut self, dir: P) -> &mut Self { self.trace_dir = dir.as_ref().to_owned(); self } #[inline(always)] pub fn set_debug_dir>(&mut self, dir: P) -> &mut Self { self.debug_dir = dir.as_ref().to_owned(); self } #[inline(always)] pub fn set_info_dir>(&mut self, dir: P) -> &mut Self { self.info_dir = dir.as_ref().to_owned(); self } #[inline(always)] pub fn set_warn_dir>(&mut self, dir: P) -> &mut Self { self.warn_dir = dir.as_ref().to_owned(); self } #[inline(always)] pub fn set_error_dir>(&mut self, dir: P) -> &mut Self { self.error_dir = dir.as_ref().to_owned(); self } #[inline(always)] pub fn is_enable(&self) -> bool { self.limit_file_size != DISABLE_LOG_FILE_SIZE } #[inline(always)] pub fn is_disable(&self) -> bool { !self.is_enable() } fn write_sync(&self, data: T, func: L, dir: &str) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { if self.is_disable() { return self; } let out: String = func(data); let path: String = get_log_path(dir, &self.path, &self.limit_file_size); let _ = append_to_file(&path, out.as_bytes()); self } async fn write_async(&self, data: T, func: L, dir: &str) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { if self.is_disable() { return self; } let out: String = func(data); let path: String = get_log_path(dir, &self.path, &self.limit_file_size); let _ = async_append_to_file(&path, out.as_bytes()).await; self } pub fn trace(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_sync(data, func, &self.trace_dir) } pub async fn async_trace(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_async(data, func, &self.trace_dir).await } pub fn debug(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_sync(data, func, &self.debug_dir) } pub async fn async_debug(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_async(data, func, &self.debug_dir).await } pub fn info(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_sync(data, func, &self.info_dir) } pub async fn async_info(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_async(data, func, &self.info_dir).await } pub fn warn(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_sync(data, func, &self.warn_dir) } pub async fn async_warn(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_async(data, func, &self.warn_dir).await } pub fn error(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_sync(data, func, &self.error_dir) } pub async fn async_error(&self, data: T, func: L) -> &Self where T: AsRef, L: FileLoggerFuncTrait, { self.write_async(data, func, &self.error_dir).await } } ``` # Path: hyperlane-log/src/struct.rs ```rust #[derive(Clone)] pub struct FileLogger { pub(super) path: String, pub(super) limit_file_size: usize, pub(super) trace_dir: String, pub(super) debug_dir: String, pub(super) info_dir: String, pub(super) warn_dir: String, pub(super) error_dir: String, } ``` # Path: hyperlane-log/src/test.rs ```rust use crate::*; #[tokio::test] async fn test() { let log: FileLogger = FileLogger::new("./logs", 1_024_000); let trace_str: String = String::from("custom trace message"); log.trace(trace_str, |trace| { let write_data: String = format!("User trace func => {trace:#?}\n"); write_data }); let debug_str: String = String::from("custom debug message"); log.debug(debug_str, |debug| { let write_data: String = format!("User debug func => {debug:#?}\n"); write_data }); let info_str: String = String::from("custom info message"); log.info(info_str, |info| { let write_data: String = format!("User info func => {info:?}\n"); write_data }); let warn_str: String = String::from("custom warn message"); log.warn(warn_str, |warn| { let write_data: String = format!("User warn func => {warn:#?}\n"); write_data }); let error_str: String = String::from("custom error message"); log.error(error_str, |error| { let write_data: String = format!("User error func => {error:?}\n"); write_data }); let async_trace_str: String = String::from("custom async trace message"); log.async_trace(async_trace_str, |trace| { let write_data: String = format!("User trace func => {trace:#?}\n"); write_data }) .await; let async_debug_str: String = String::from("custom async debug message"); log.async_debug(async_debug_str, |debug| { let write_data: String = format!("User debug func => {debug:#?}\n"); write_data }) .await; let async_info_str: String = String::from("custom async info message"); log.async_info(async_info_str, |info| { let write_data: String = format!("User info func => {info:?}\n"); write_data }) .await; let async_warn_str: String = String::from("custom async warn message"); log.async_warn(async_warn_str, |warn| { let write_data: String = format!("User warn func => {warn:#?}\n"); write_data }) .await; let async_error_str: String = String::from("custom async error message"); log.async_error(async_error_str, |error| { let write_data: String = format!("User error func => {error:?}\n"); write_data }) .await; } #[tokio::test] async fn test_more_log_first() { let log: FileLogger = FileLogger::new("./logs", DISABLE_LOG_FILE_SIZE); log.trace("trace data => ", |trace| { let write_data: String = format!("User trace func => {trace:#?}\n"); write_data }); log.debug("debug data => ", |debug| { let write_data: String = format!("User debug func => {debug:#?}\n"); write_data }); log.info("info data => ", |info| { let write_data: String = format!("User info func => {info:?}\n"); write_data }); log.warn("warn data => ", |warn| { let write_data: String = format!("User warn func => {warn:#?}\n"); write_data }); log.error("error data => ", |error| { let write_data: String = format!("User error func => {error:?}\n"); write_data }); log.async_trace("async trace data => ", |trace| { let write_data: String = format!("User trace func => {trace:#?}\n"); write_data }) .await; log.async_debug("async debug data => ", |debug| { let write_data: String = format!("User debug func => {debug:#?}\n"); write_data }) .await; log.async_info("async info data => ", |info| { let write_data: String = format!("User info func => {info:?}\n"); write_data }) .await; log.async_warn("async warn data => ", |warn| { let write_data: String = format!("User warn func => {warn:#?}\n"); write_data }) .await; log.async_error("async error data => ", |error| { let write_data: String = format!("User error func => {error:?}\n"); write_data }) .await; } #[tokio::test] async fn test_more_log_second() { for _ in 0..10 { let log: FileLogger = FileLogger::new("./logs", 512_000); log.trace("trace data!\n", common_log); log.async_trace("async trace data!\n", common_log).await; log.debug("debug data!\n", common_log); log.async_debug("async debug data!\n", common_log).await; log.info("info data!\n", common_log); log.async_info("async info data!\n", common_log).await; log.warn("warn data!\n", common_log); log.async_warn("async warn data!\n", common_log).await; log.error("error data!\n", common_log); log.async_error("async error data!\n", common_log).await; } } #[tokio::test] async fn test_set_log_level_dirs() { let mut log: FileLogger = FileLogger::new("./test_logs", 1_024_000); log.set_trace_dir("custom_trace") .set_debug_dir("custom_debug") .set_info_dir("custom_info") .set_warn_dir("custom_warn") .set_error_dir("custom_error"); assert_eq!(log.get_trace_dir(), "custom_trace"); assert_eq!(log.get_debug_dir(), "custom_debug"); assert_eq!(log.get_info_dir(), "custom_info"); assert_eq!(log.get_warn_dir(), "custom_warn"); assert_eq!(log.get_error_dir(), "custom_error"); log.trace("test trace message", common_log); log.debug("test debug message", common_log); log.info("test info message", common_log); log.warn("test warn message", common_log); log.error("test error message", common_log); log.async_trace("async test trace message", common_log) .await; log.async_debug("async test debug message", common_log) .await; log.async_info("async test info message", common_log).await; log.async_warn("async test warn message", common_log).await; log.async_error("async test error message", common_log) .await; } #[tokio::test] async fn test_log_level_dir_constants() { let log: FileLogger = FileLogger::default(); assert_eq!(log.get_trace_dir(), TRACE_DIR); assert_eq!(log.get_debug_dir(), DEBUG_DIR); assert_eq!(log.get_info_dir(), INFO_DIR); assert_eq!(log.get_warn_dir(), WARN_DIR); assert_eq!(log.get_error_dir(), ERROR_DIR); } #[tokio::test] async fn test_log_level_dir_method_chaining() { let mut log: FileLogger = FileLogger::new("./logs", 512_000); let log_ref: &mut FileLogger = log .set_trace_dir("chain_trace") .set_debug_dir("chain_debug") .set_info_dir("chain_info") .set_warn_dir("chain_warn") .set_error_dir("chain_error"); assert_eq!(log_ref.get_trace_dir(), "chain_trace"); assert_eq!(log_ref.get_debug_dir(), "chain_debug"); assert_eq!(log_ref.get_info_dir(), "chain_info"); assert_eq!(log_ref.get_warn_dir(), "chain_warn"); assert_eq!(log_ref.get_error_dir(), "chain_error"); } #[tokio::test] async fn test_log_level_dirs_with_special_characters() { let mut log: FileLogger = FileLogger::new("./logs/special", 1_024_000); log.set_trace_dir("trace-2024") .set_debug_dir("debug_test") .set_info_dir("info.logs") .set_warn_dir("warn/logs") .set_error_dir("error_logs"); log.trace("special trace message", common_log); log.async_trace("async special trace message", common_log) .await; log.debug("special debug message", common_log); log.async_debug("async special debug message", common_log) .await; log.info("special info message", common_log); log.async_info("async special info message", common_log) .await; log.warn("special warn message", common_log); log.async_warn("async special warn message", common_log) .await; log.error("special error message", common_log); log.async_error("async special error message", common_log) .await; } #[tokio::test] async fn test_log_level_dirs_edge_cases() { let mut log: FileLogger = FileLogger::new("./logs", 512_000); log.set_trace_dir("") .set_debug_dir("") .set_info_dir("") .set_warn_dir("") .set_error_dir(""); assert_eq!(log.get_trace_dir(), ""); assert_eq!(log.get_debug_dir(), ""); assert_eq!(log.get_info_dir(), ""); assert_eq!(log.get_warn_dir(), ""); assert_eq!(log.get_error_dir(), ""); log.trace("empty dir trace", common_log); log.debug("empty dir debug", common_log); log.info("empty dir info", common_log); log.warn("empty dir warn", common_log); log.error("empty dir error", common_log); log.set_trace_dir("valid_trace") .set_debug_dir("valid_debug") .set_info_dir("valid_info") .set_warn_dir("valid_warn") .set_error_dir("valid_error"); let long_dir_name: String = "a".repeat(200); log.set_trace_dir(&long_dir_name); assert_eq!(log.get_trace_dir().as_str(), long_dir_name.as_str()); } ```