refactor: migrate hash functions to filter_functions (Phase 2)

Implement unified filter-function pattern for hash functions:
- Create filter_functions/hash.rs with Md5, Sha1, Sha256, Sha512
- Implement FilterFunction trait for all hash functions
- Register as both functions AND filters
- Remove old functions/hash.rs module
- Update unit tests for both syntaxes
- Add integration tests for filter syntax and chaining

Both syntaxes now work identically:
- Function: {{ sha256(string="hello") }}
- Filter: {{ "hello" | sha256 }}
- Chaining: {{ "hello" | sha256 | md5 }}

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: bordeux

src/filter_functions/hash.rs

@@ -0,0 +1,174 @@
+//! Hash functions that support both function and filter syntax.
+//!
+//! # Function Syntax
+//! ```jinja
+//! {{ md5(string="hello") }}
+//! {{ sha256(string="hello world") }}
+//! ```
+//!
+//! # Filter Syntax
+//! ```jinja
+//! {{ "hello" | md5 }}
+//! {{ "hello world" | sha256 }}
+//! ```
+//!
+//! # Chaining
+//! ```jinja
+//! {{ "hello" | sha256 | md5 }}
+//! ```
+
+use super::FilterFunction;
+use minijinja::value::Kwargs;
+use minijinja::{Error, ErrorKind, Value};
+
+/// MD5 hash function.
+///
+/// # Function Syntax
+/// ```jinja
+/// {{ md5(string="hello") }}
+/// ```
+///
+/// # Filter Syntax
+/// ```jinja
+/// {{ "hello" | md5 }}
+/// ```
+pub struct Md5;
+
+impl Md5 {
+    fn hash(input: &str) -> String {
+        use md5::{Digest, Md5 as Md5Hasher};
+        let mut hasher = Md5Hasher::new();
+        hasher.update(input.as_bytes());
+        format!("{:x}", hasher.finalize())
+    }
+}
+
+impl FilterFunction for Md5 {
+    const NAME: &'static str = "md5";
+
+    fn call_as_function(kwargs: Kwargs) -> Result<Value, Error> {
+        let input: String = kwargs.get("string")?;
+        Ok(Value::from(Self::hash(&input)))
+    }
+
+    fn call_as_filter(value: &Value, _kwargs: Kwargs) -> Result<Value, Error> {
+        let input = value
+            .as_str()
+            .ok_or_else(|| Error::new(ErrorKind::InvalidOperation, "md5 requires a string"))?;
+        Ok(Value::from(Self::hash(input)))
+    }
+}
+
+/// SHA1 hash function.
+///
+/// # Function Syntax
+/// ```jinja
+/// {{ sha1(string="hello") }}
+/// ```
+///
+/// # Filter Syntax
+/// ```jinja
+/// {{ "hello" | sha1 }}
+/// ```
+pub struct Sha1;
+
+impl Sha1 {
+    fn hash(input: &str) -> String {
+        use sha1::{Digest, Sha1 as Sha1Hasher};
+        let mut hasher = Sha1Hasher::new();
+        hasher.update(input.as_bytes());
+        format!("{:x}", hasher.finalize())
+    }
+}
+
+impl FilterFunction for Sha1 {
+    const NAME: &'static str = "sha1";
+
+    fn call_as_function(kwargs: Kwargs) -> Result<Value, Error> {
+        let input: String = kwargs.get("string")?;
+        Ok(Value::from(Self::hash(&input)))
+    }
+
+    fn call_as_filter(value: &Value, _kwargs: Kwargs) -> Result<Value, Error> {
+        let input = value
+            .as_str()
+            .ok_or_else(|| Error::new(ErrorKind::InvalidOperation, "sha1 requires a string"))?;
+        Ok(Value::from(Self::hash(input)))
+    }
+}
+
+/// SHA256 hash function.
+///
+/// # Function Syntax
+/// ```jinja
+/// {{ sha256(string="hello") }}
+/// ```
+///
+/// # Filter Syntax
+/// ```jinja
+/// {{ "hello" | sha256 }}
+/// ```
+pub struct Sha256;
+
+impl Sha256 {
+    fn hash(input: &str) -> String {
+        use sha2::{Digest, Sha256 as Sha256Hasher};
+        let mut hasher = Sha256Hasher::new();
+        hasher.update(input.as_bytes());
+        format!("{:x}", hasher.finalize())
+    }
+}
+
+impl FilterFunction for Sha256 {
+    const NAME: &'static str = "sha256";
+
+    fn call_as_function(kwargs: Kwargs) -> Result<Value, Error> {
+        let input: String = kwargs.get("string")?;
+        Ok(Value::from(Self::hash(&input)))
+    }
+
+    fn call_as_filter(value: &Value, _kwargs: Kwargs) -> Result<Value, Error> {
+        let input = value
+            .as_str()
+            .ok_or_else(|| Error::new(ErrorKind::InvalidOperation, "sha256 requires a string"))?;
+        Ok(Value::from(Self::hash(input)))
+    }
+}
+
+/// SHA512 hash function.
+///
+/// # Function Syntax
+/// ```jinja
+/// {{ sha512(string="hello") }}
+/// ```
+///
+/// # Filter Syntax
+/// ```jinja
+/// {{ "hello" | sha512 }}
+/// ```
+pub struct Sha512;
+
+impl Sha512 {
+    fn hash(input: &str) -> String {
+        use sha2::{Digest, Sha512 as Sha512Hasher};
+        let mut hasher = Sha512Hasher::new();
+        hasher.update(input.as_bytes());
+        format!("{:x}", hasher.finalize())
+    }
+}
+
+impl FilterFunction for Sha512 {
+    const NAME: &'static str = "sha512";
+
+    fn call_as_function(kwargs: Kwargs) -> Result<Value, Error> {
+        let input: String = kwargs.get("string")?;
+        Ok(Value::from(Self::hash(&input)))
+    }
+
+    fn call_as_filter(value: &Value, _kwargs: Kwargs) -> Result<Value, Error> {
+        let input = value
+            .as_str()
+            .ok_or_else(|| Error::new(ErrorKind::InvalidOperation, "sha512 requires a string"))?;
+        Ok(Value::from(Self::hash(input)))
+    }
+}

src/filter_functions/mod.rs

@@ -26,6 +26,7 @@
 //! {{ "hello" | sha256 | base64_encode }}
 //! ```
 
+pub mod hash;
 pub mod traits;
 
 pub use traits::FilterFunction;
@@ -46,12 +47,12 @@ use minijinja::Environment;
 /// let mut env = Environment::new();
 /// filter_functions::register_all(&mut env);
 /// ```
-pub fn register_all(_env: &mut Environment) {
+pub fn register_all(env: &mut Environment) {
     // Phase 2: Hash functions
-    // hash::Md5::register(env);
-    // hash::Sha1::register(env);
-    // hash::Sha256::register(env);
-    // hash::Sha512::register(env);
+    hash::Md5::register(env);
+    hash::Sha1::register(env);
+    hash::Sha256::register(env);
+    hash::Sha512::register(env);
 
     // Phase 3: Encoding functions
     // encoding::Base64Encode::register(env);

src/functions/hash.rs

@@ -14,10 +14,6 @@
 //!
 //! tmpltool provides additional custom functions:
 //! - `filter_env(pattern)` - Filter environment variables by glob pattern (e.g., "SERVER_*")
-//! - `md5(string)` - Calculate MD5 hash of a string
-//! - `sha1(string)` - Calculate SHA1 hash of a string
-//! - `sha256(string)` - Calculate SHA256 hash of a string
-//! - `sha512(string)` - Calculate SHA512 hash of a string
 //! - `uuid(version)` - Generate a UUID (v4 default, or v7 for time-ordered)
 //! - `random_string(length, charset)` - Generate a random string with custom length and character set
 //! - `read_file(path)` - Read content from a file
@@ -77,7 +73,6 @@ pub mod encoding;
 pub mod environment;
 pub mod exec;
 pub mod filesystem;
-pub mod hash;
 pub mod kubernetes;
 pub mod logic;
 pub mod math;
@@ -140,10 +135,7 @@ pub fn register_all(env: &mut Environment, context: TemplateContext) {
 
     // Register custom functions (simple, no context needed)
     env.add_function("filter_env", environment::filter_env_fn);
-    env.add_function("md5", hash::md5_fn);
-    env.add_function("sha1", hash::sha1_fn);
-    env.add_function("sha256", hash::sha256_fn);
-    env.add_function("sha512", hash::sha512_fn);
+    // Hash functions (md5, sha1, sha256, sha512) are now registered via filter_functions module
     env.add_function("uuid", uuid_gen::uuid_fn);
     env.add_function("random_string", random::random_string_fn);