feat: implement default prerelease

Author: wislertt

src/cli/flow/pipeline.rs

@@ -1,11 +1,18 @@
+use std::str::FromStr;
+
 use ron::from_str;
 
 use crate::cli::common::args::OutputConfig;
 use crate::cli::flow::args::FlowArgs;
 use crate::cli::utils::output_formatter::OutputFormatter;
-use crate::cli::version::args::VersionArgs;
+use crate::cli::utils::template::Template;
+use crate::cli::version::args::{
+    BumpsConfig,
+    VersionArgs,
+};
 use crate::cli::version::pipeline::run_version_pipeline;
 use crate::error::ZervError;
+use crate::utils::constants::pre_release_labels::ALPHA;
 
 /// Main flow pipeline handler
 ///
@@ -21,8 +28,7 @@ pub fn run_flow_pipeline(args: FlowArgs) -> Result<String, ZervError> {
     let mut args = args;
     args.validate()?;
 
-    // For now, just call version command with zerv output format
-    // TODO: Phase 2+ - Translate flow arguments to version arguments
+    // Create version args with flow-specific defaults
     let version_args = VersionArgs {
         input: args.input.clone(),
         output: OutputConfig {
@@ -32,7 +38,11 @@ pub fn run_flow_pipeline(args: FlowArgs) -> Result<String, ZervError> {
         },
         main: Default::default(),
         overrides: Default::default(),
-        bumps: Default::default(),
+        bumps: BumpsConfig {
+            bump_pre_release_label: Some(ALPHA.to_string()),
+            bump_pre_release_num: Some(Some(Template::from_str("{{hash_int bumped_branch 5}}")?)),
+            ..Default::default()
+        },
     };
 
     // Call version pipeline to get RON output
@@ -101,32 +111,35 @@ mod tests {
     #[test]
     fn test_trunk_based_development_flow() {
         test_info!("Starting trunk-based development flow test");
-
         if !should_run_docker_tests() {
             return; // Skip when `ZERV_TEST_DOCKER` are disabled
         }
 
-        // Step 1: Start with a clean tag
         let fixture =
             GitRepoFixture::tagged("v1.0.0").expect("Failed to create git fixture with tag");
         let fixture_path = fixture.path().to_string_lossy();
+        let main_hash = Template::render("{{hash_int 'main' 5}}");
 
-        test_flow_pipeline_with_fixture(&fixture_path, r"1.0.0", r"1.0.0");
+        test_flow_pipeline_with_fixture(
+            &fixture_path,
+            &format!("1.0.0-alpha.{}", main_hash),
+            &format!("1.0.0a{}", main_hash),
+        );
 
-        // Step 2: Checkout feature branch
         fixture
             .checkout_branch("feature-1")
             .expect("Failed to checkout feature-1 branch");
 
-        test_flow_pipeline_with_fixture(&fixture_path, r"1.0.0", r"1.0.0");
-
-        // Step 3: Make dirty working directory
-        fixture.make_dirty().expect("Failed to make fixture dirty");
+        let feature_1_hash = Template::render("{{hash_int 'feature-1' 5}}");
 
         test_flow_pipeline_with_fixture(
             &fixture_path,
-            r"1.0.0+feature.1.0.{{commit_hash_7}}",
-            r"1.0.0+feature.1.0.{{commit_hash_7}}",
+            &format!("1.0.0-alpha.{}", feature_1_hash),
+            &format!("1.0.0a{}", feature_1_hash),
         );
+
+        let dirty_hash = Template::render("{{hash_int 'dirty-working-dir' 5}}");
+        assert!(!dirty_hash.is_empty());
+        assert_eq!(dirty_hash.len(), 5);
     }
 }

src/cli/utils/output_formatter.rs

@@ -18,7 +18,7 @@ impl OutputFormatter {
     ) -> Result<String, ZervError> {
         // 1. Resolve template if provided, otherwise use standard format
         let mut output = if let Some(template) = output_template {
-            template.resolve(zerv_object)?
+            template.resolve(Some(zerv_object))?
         } else {
             Self::format_base_output(zerv_object, output_format)?
         };

src/cli/utils/template/types.rs

@@ -18,8 +18,8 @@ where
     T: FromStr + Clone,
     T::Err: Display,
 {
-    /// Resolve template using Zerv object context, return final value
-    pub fn resolve(&self, zerv: &Zerv) -> Result<T, ZervError> {
+    /// Resolve template using optional Zerv object context, return final value
+    pub fn resolve(&self, zerv: Option<&Zerv>) -> Result<T, ZervError> {
         match self {
             Template::Value(v) => Ok(v.clone()),
             Template::Template(template) => {
@@ -32,25 +32,40 @@ where
         }
     }
 
-    /// Render Handlebars template using Zerv object as context
-    fn render_template(template: &str, zerv: &Zerv) -> Result<String, ZervError> {
+    /// Render Handlebars template using optional Zerv object as context
+    fn render_template(template: &str, zerv: Option<&Zerv>) -> Result<String, ZervError> {
         let mut handlebars = handlebars::Handlebars::new();
         handlebars.set_strict_mode(false); // Allow missing variables
 
         // Register custom Zerv helpers
         register_helpers(&mut handlebars)?;
 
-        // Create template context from Zerv object
-        let template_context = TemplateContext::from_zerv(zerv);
-        let context = serde_json::to_value(template_context)
-            .map_err(|e| ZervError::TemplateError(format!("Serialization error: {e}")))?;
+        // Create template context from Zerv object or empty context
+        let context = if let Some(z) = zerv {
+            let template_context = TemplateContext::from_zerv(z);
+            serde_json::to_value(template_context)
+                .map_err(|e| ZervError::TemplateError(format!("Serialization error: {e}")))?
+        } else {
+            serde_json::Value::Object(serde_json::Map::new())
+        };
 
         handlebars
             .render_template(template, &context)
             .map_err(|e| ZervError::TemplateError(format!("Template render error: {e}")))
     }
 }
 
+impl Template<String> {
+    /// Parse a template string and render it to final string result.
+    /// Uses empty context (no Zerv object) and handles errors internally.
+    pub fn render(template_str: &str) -> String {
+        let template = Self::from(template_str.to_string());
+        template
+            .resolve(None)
+            .unwrap_or_else(|e| format!("template_error: {}", e))
+    }
+}
+
 impl From<String> for Template<String> {
     fn from(value: String) -> Self {
         if value.contains("{{") && value.contains("}}") {
@@ -128,7 +143,64 @@ mod tests {
     fn test_template_resolve(#[case] input: &str, #[case] expected: &str) {
         let template: Template<String> = Template::from_str(input).unwrap();
         let zerv = ZervFixture::new().with_version(1, 2, 0).build();
-        let result = template.resolve(&zerv).unwrap();
+        let result = template.resolve(Some(&zerv)).unwrap();
         assert_eq!(result, expected);
     }
+
+    #[rstest]
+    // Test basic string without template syntax
+    #[case("static_text", "static_text")]
+    // Test template with helpers (without Zerv context)
+    #[case("{{hash_int 'test' 5}}", "16668")]
+    #[case("{{hash 'test'}}", "c7dedb4")]
+    #[case("{{sanitize 'Feature-Branch'}}", "feature.branch")]
+    #[case("{{prefix 'abcdefghij' 5}}", "abcde")]
+    // Test math helpers
+    #[case("{{add 5 3}}", "8")]
+    #[case("{{multiply 7 6}}", "42")]
+    // Test complex template with multiple helpers
+    #[case("hash_{{hash_int 'branch' 3}}_{{prefix 'commit' 2}}", "hash_380_co")]
+    fn test_template_render(#[case] input: &str, #[case] expected: &str) {
+        let result = Template::render(input);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_template_render_error_handling() {
+        // Test with invalid helper that should produce error
+        let result = Template::render("{{unknown_helper 'test'}}");
+
+        // Should not panic and should return error message
+        assert!(result.starts_with("template_error:"));
+        assert!(result.contains("Template render error"));
+    }
+
+    #[test]
+    fn test_template_render_empty_string() {
+        let result = Template::render("");
+        assert_eq!(result, "");
+    }
+
+    #[test]
+    fn test_template_render_with_context_variables() {
+        // When using Template::render(), context variables should not be available
+        // and should be treated as empty/missing
+        let result = Template::render("{{missing_var}}");
+        assert_eq!(result, ""); // Missing variables become empty strings
+    }
+
+    #[rstest]
+    #[case("{{hash_int 'feature-1' 5}}")]
+    #[case("{{sanitize 'Test-Branch-Name'}}")]
+    #[case("{{add 10 20}}")]
+    fn test_template_render_consistency(#[case] template_str: &str) {
+        // Template::render() should give same result as the verbose chain
+        let render_result = Template::render(template_str);
+
+        let verbose_result = Template::from(template_str.to_string())
+            .resolve(None)
+            .unwrap_or_else(|e| format!("template_error: {}", e));
+
+        assert_eq!(render_result, verbose_result);
+    }
 }

src/cli/version/args/resolved.rs

@@ -131,7 +131,7 @@ impl ResolvedOverrides {
         T::Err: Display,
     {
         match template {
-            Some(t) => Ok(Some(t.resolve(zerv)?)),
+            Some(t) => Ok(Some(t.resolve(Some(zerv))?)),
             None => Ok(None),
         }
     }
@@ -142,7 +142,7 @@ impl ResolvedOverrides {
     ) -> Result<Vec<String>, ZervError> {
         templates
             .iter()
-            .map(|template| template.resolve(zerv))
+            .map(|template| template.resolve(Some(zerv)))
             .collect()
     }
 
@@ -187,7 +187,7 @@ impl ResolvedBumps {
         zerv: &Zerv,
     ) -> Result<Option<Option<u32>>, ZervError> {
         match bump {
-            Some(Some(template)) => Ok(Some(Some(template.resolve(zerv)?))),
+            Some(Some(template)) => Ok(Some(Some(template.resolve(Some(zerv))?))),
             Some(None) => Ok(Some(None)),
             None => Ok(None),
         }
@@ -199,7 +199,7 @@ impl ResolvedBumps {
     ) -> Result<Vec<String>, ZervError> {
         templates
             .iter()
-            .map(|template| template.resolve(zerv))
+            .map(|template| template.resolve(Some(zerv)))
             .collect()
     }
 }