feat: v0.1.8

Author: eastspire

.gitignore

@@ -1,2 +1,3 @@
+/tmp
 /target
 Cargo.lock

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hyperlane-cli"
-version = "0.1.7"
+version = "0.1.8"
 readme = "README.md"
 edition = "2024"
 authors = ["root@ltpp.vip"]
@@ -9,7 +9,7 @@ description = """A command-line tool for Hyperlane framework."""
 keywords = ["output", "console", "log", "print", "color"]
 repository = "https://github.com/hyperlane-dev/hyperlane-cli"
 categories = ["command-line-interface", "development-tools", "visualization"]
-exclude = ["target", "Cargo.lock", "sh", ".github"]
+exclude = ["target", "Cargo.lock", "sh", ".github", "tmp"]
 
 [dependencies]
 toml = "0.9.8"

src/bump/mod.rs

@@ -2,4 +2,7 @@ mod r#enum;
 mod r#fn;
 mod r#struct;
 
+#[cfg(test)]
+mod test;
+
 pub(crate) use {r#enum::*, r#fn::*, r#struct::*};

src/bump/test.rs

@@ -0,0 +1,193 @@
+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<String, Box<dyn std::error::Error>> =
+        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<String, Box<dyn std::error::Error>> =
+        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<String, Box<dyn std::error::Error>> =
+        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<String, Box<dyn std::error::Error>> =
+        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<String, Box<dyn std::error::Error>> =
+        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<String, Box<dyn std::error::Error>> =
+        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<String, Box<dyn std::error::Error>> =
+        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<String, Box<dyn std::error::Error>> =
+        execute_bump(manifest_path.to_str().unwrap(), &BumpVersionType::Patch);
+    assert!(result.is_err());
+}

src/command/enum.rs

@@ -11,6 +11,8 @@ pub(crate) enum CommandType {
     Publish,
     /// Create a new project from template
     New,
+    /// Generate template components
+    Template,
     /// Show help
     Help,
     /// Show version

src/config/fn.rs

@@ -1,3 +1,5 @@
+use std::str::FromStr;
+
 use crate::*;
 
 /// Parse command line arguments
@@ -13,6 +15,9 @@ pub(crate) fn parse_args() -> Args {
     let mut bump_type: Option<BumpVersionType> = None;
     let mut max_retries: u32 = 3;
     let mut project_name: Option<String> = None;
+    let mut template_type: Option<TemplateType> = None;
+    let mut model_sub_type: Option<ModelSubType> = None;
+    let mut component_name: Option<String> = None;
     let mut i: usize = 1;
     while i < raw_args.len() {
         let arg: &str = raw_args[i].as_str();
@@ -57,6 +62,37 @@ pub(crate) fn parse_args() -> Args {
                     }
                 }
             }
+            "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);
             }
@@ -106,5 +142,8 @@ pub(crate) fn parse_args() -> Args {
         bump_type,
         max_retries,
         project_name,
+        template_type,
+        model_sub_type,
+        component_name,
     }
 }

src/config/mod.rs

@@ -1,4 +1,7 @@
 mod r#fn;
 mod r#struct;
 
+#[cfg(test)]
+mod test;
+
 pub(crate) use {r#fn::*, r#struct::*};

src/config/struct.rs

@@ -15,4 +15,10 @@ pub struct Args {
     pub max_retries: u32,
     /// Project name for new command
     pub project_name: Option<String>,
+    /// Template type for template command
+    pub template_type: Option<TemplateType>,
+    /// Model subtype for template command (only when template_type is Model)
+    pub model_sub_type: Option<ModelSubType>,
+    /// Component name for template command
+    pub component_name: Option<String>,
 }