style: fix formatting issues for CI

Run cargo fmt to fix formatting in:
- src/filter_functions/encoding.rs
- tests/test_datetime_unit.rs
- tests/test_encoding_functions.rs
- tests/test_filters_integration.rs
- tests/test_network_functions.rs

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

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

Author: bordeux

src/filter_functions/encoding.rs

@@ -50,7 +50,10 @@ impl FilterFunction for Base64Encode {
 
     fn call_as_filter(value: &Value, _kwargs: Kwargs) -> Result<Value, Error> {
         let input = value.as_str().ok_or_else(|| {
-            Error::new(ErrorKind::InvalidOperation, "base64_encode requires a string")
+            Error::new(
+                ErrorKind::InvalidOperation,
+                "base64_encode requires a string",
+            )
         })?;
         Ok(Value::from(Self::encode(input)))
     }
@@ -99,7 +102,10 @@ impl FilterFunction for Base64Decode {
 
     fn call_as_filter(value: &Value, _kwargs: Kwargs) -> Result<Value, Error> {
         let input = value.as_str().ok_or_else(|| {
-            Error::new(ErrorKind::InvalidOperation, "base64_decode requires a string")
+            Error::new(
+                ErrorKind::InvalidOperation,
+                "base64_decode requires a string",
+            )
         })?;
         Ok(Value::from(Self::decode(input)?))
     }
@@ -298,7 +304,10 @@ impl FilterFunction for EscapeShell {
 
     fn call_as_filter(value: &Value, _kwargs: Kwargs) -> Result<Value, Error> {
         let input = value.as_str().ok_or_else(|| {
-            Error::new(ErrorKind::InvalidOperation, "escape_shell requires a string")
+            Error::new(
+                ErrorKind::InvalidOperation,
+                "escape_shell requires a string",
+            )
         })?;
         Ok(Value::from(Self::escape(input)))
     }

tests/test_datetime_unit.rs

@@ -18,9 +18,15 @@ fn test_now_fn_returns_timestamp() {
     let timestamp = result.as_i64().unwrap();
 
     // Should be a reasonable Unix timestamp (after 2020-01-01)
-    assert!(timestamp > 1577836800, "Timestamp should be after 2020-01-01");
+    assert!(
+        timestamp > 1577836800,
+        "Timestamp should be after 2020-01-01"
+    );
     // Should be before 2100-01-01
-    assert!(timestamp < 4102444800, "Timestamp should be before 2100-01-01");
+    assert!(
+        timestamp < 4102444800,
+        "Timestamp should be before 2100-01-01"
+    );
 }
 
 #[test]
@@ -29,7 +35,10 @@ fn test_now_fn_returns_integer() {
 
     // Should be an integer, not a string
     assert!(result.as_i64().is_some(), "now() should return an integer");
-    assert!(result.as_str().is_none(), "now() should not return a string");
+    assert!(
+        result.as_str().is_none(),
+        "now() should not return a string"
+    );
 }
 
 #[test]
@@ -42,7 +51,12 @@ fn test_now_fn_monotonic() {
     let result2 = now_fn(empty_kwargs()).unwrap();
     let ts2 = result2.as_i64().unwrap();
 
-    assert!(ts2 >= ts1, "Timestamps should be monotonic: {} >= {}", ts2, ts1);
+    assert!(
+        ts2 >= ts1,
+        "Timestamps should be monotonic: {} >= {}",
+        ts2,
+        ts1
+    );
 }
 
 // ==================== now() with format parameter ====================
@@ -55,8 +69,14 @@ fn test_now_fn_with_format_date_only() {
     // Should match YYYY-MM-DD pattern
     assert_eq!(formatted.len(), 10, "Date format should be 10 chars");
     assert!(formatted.contains('-'), "Should contain date separators");
-    assert!(!formatted.contains('T'), "Should not contain time separator");
-    assert!(!formatted.contains(':'), "Should not contain time separators");
+    assert!(
+        !formatted.contains('T'),
+        "Should not contain time separator"
+    );
+    assert!(
+        !formatted.contains(':'),
+        "Should not contain time separators"
+    );
 }
 
 #[test]
@@ -66,7 +86,10 @@ fn test_now_fn_with_format_datetime() {
 
     // Should match YYYY-MM-DD HH:MM:SS pattern (19 chars)
     assert_eq!(formatted.len(), 19, "DateTime format should be 19 chars");
-    assert!(formatted.contains(' '), "Should contain space between date and time");
+    assert!(
+        formatted.contains(' '),
+        "Should contain space between date and time"
+    );
     assert!(formatted.contains(':'), "Should contain time separators");
 }
 
@@ -87,15 +110,22 @@ fn test_now_fn_with_format_year_only() {
 
     assert_eq!(formatted.len(), 4, "Year should be 4 digits");
     let year: i32 = formatted.parse().unwrap();
-    assert!((2020..=2100).contains(&year), "Year should be reasonable: {}", year);
+    assert!(
+        (2020..=2100).contains(&year),
+        "Year should be reasonable: {}",
+        year
+    );
 }
 
 #[test]
 fn test_now_fn_with_format_returns_string() {
     let result = now_fn(kwargs_with_format("%Y-%m-%d")).unwrap();
 
     // With format, should return a string
-    assert!(result.as_str().is_some(), "now(format=...) should return a string");
+    assert!(
+        result.as_str().is_some(),
+        "now(format=...) should return a string"
+    );
 }
 
 #[test]

tests/test_encoding_functions.rs

@@ -5,10 +5,10 @@
 
 use minijinja::value::Kwargs;
 use minijinja::{Environment, Value};
+use tmpltool::filter_functions::FilterFunction;
 use tmpltool::filter_functions::encoding::{
     Base64Decode, Base64Encode, EscapeHtml, EscapeShell, EscapeXml, HexDecode, HexEncode,
 };
-use tmpltool::filter_functions::FilterFunction;
 use tmpltool::functions::encoding;
 
 // Helper to test both function and filter syntax produce the same result
@@ -173,8 +173,7 @@ fn test_hex_encode_both_syntaxes() {
 #[test]
 fn test_hex_encode_empty() {
     let result =
-        HexEncode::call_as_function(Kwargs::from_iter(vec![("string", Value::from(""))]))
-            .unwrap();
+        HexEncode::call_as_function(Kwargs::from_iter(vec![("string", Value::from(""))])).unwrap();
     assert_eq!(result.as_str().unwrap(), "");
 }
 
@@ -317,8 +316,7 @@ fn test_escape_html_all_entities() {
 #[test]
 fn test_escape_html_empty() {
     let result =
-        EscapeHtml::call_as_function(Kwargs::from_iter(vec![("string", Value::from(""))]))
-            .unwrap();
+        EscapeHtml::call_as_function(Kwargs::from_iter(vec![("string", Value::from(""))])).unwrap();
     assert_eq!(result.as_str().unwrap(), "");
 }
 

tests/test_filters_integration.rs

@@ -293,7 +293,9 @@ SHA512: {{ "test" | sha512 }}"#;
     let output = fs::read_to_string(&output_path).unwrap();
     assert!(output.contains("MD5: 098f6bcd4621d373cade4e832627b4f6"));
     assert!(output.contains("SHA1: a94a8fe5ccb19ba61c4c0873d391e987982fbbd3"));
-    assert!(output.contains("SHA256: 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"));
+    assert!(
+        output.contains("SHA256: 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08")
+    );
     assert!(output.contains("SHA512: ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff"));
 
     cleanup_test_file(&template_path);
@@ -416,7 +418,10 @@ fn test_escape_html_filter_in_template() {
     assert!(result.is_ok());
 
     let output = fs::read_to_string(&output_path).unwrap();
-    assert_eq!(output, "<script>alert('XSS')</script>");
+    assert_eq!(
+        output,
+        "<script>alert('XSS')</script>"
+    );
 
     cleanup_test_file(&template_path);
     cleanup_test_file(&output_path);

tests/test_network_functions.rs

@@ -30,7 +30,10 @@ fn test_get_interfaces_has_loopback() {
         }
     }
 
-    assert!(found_loopback, "Should have at least one loopback interface");
+    assert!(
+        found_loopback,
+        "Should have at least one loopback interface"
+    );
 }
 
 #[test]
@@ -46,12 +49,18 @@ fn test_get_interfaces_has_required_fields() {
 
         assert!(name.is_ok(), "Interface should have 'name' field");
         assert!(ip.is_ok(), "Interface should have 'ip' field");
-        assert!(is_loopback.is_ok(), "Interface should have 'is_loopback' field");
+        assert!(
+            is_loopback.is_ok(),
+            "Interface should have 'is_loopback' field"
+        );
 
         // Name should be a non-empty string
         let name_str = name.unwrap();
         assert!(name_str.as_str().is_some(), "Name should be a string");
-        assert!(!name_str.as_str().unwrap().is_empty(), "Name should not be empty");
+        assert!(
+            !name_str.as_str().unwrap().is_empty(),
+            "Name should not be empty"
+        );
 
         // IP should be a valid IP address
         let ip_str = ip.unwrap();