feat: enhance build_url with default scheme and object query support

Improvements to build_url function:

1. Default scheme: Defaults to "https" if scheme parameter is not provided
   - Users can still override with scheme="http" or any other scheme
   - Makes the API more convenient for common HTTPS use cases

2. Query parameter now accepts both strings and objects:
   - String: Works as before, passed through directly
   - Object: Automatically serialized to query string
   - Cleaner syntax: build_url(host="api.com", query={"page": 1})

Examples:
- {{ build_url(host="example.com") }} → https://example.com/
- {{ build_url(scheme="http", host="localhost") }} → http://localhost/
- {{ build_url(host="api.com", query="page=1&limit=20") }}
- {{ build_url(host="api.com", query={"page": 1, "limit": 20}) }}

Tests:
- Added 3 new unit tests for default scheme and object queries
- Updated integration tests with new test cases
- All 34 unit tests passing

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

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

Author: bordeux

src/functions/url.rs

@@ -105,11 +105,11 @@ pub fn parse_url_fn(kwargs: Kwargs) -> Result<Value, Error> {
 ///
 /// # Arguments
 ///
-/// * `scheme` - The URL scheme (http, https, etc.)
-/// * `host` - The hostname
+/// * `scheme` - Optional URL scheme (default: "https")
+/// * `host` - The hostname (required)
 /// * `port` - Optional port number
 /// * `path` - Optional path component (default: "/")
-/// * `query` - Optional query string (without ?)
+/// * `query` - Optional query string (string) or object (will be serialized)
 ///
 /// # Returns
 ///
@@ -118,14 +118,15 @@ pub fn parse_url_fn(kwargs: Kwargs) -> Result<Value, Error> {
 /// # Example
 ///
 /// ```jinja
-/// {{ build_url(scheme="https", host="api.example.com", port=8080, path="/v1/users", query="limit=10") }}
+/// {{ build_url(host="api.example.com", port=8080, path="/v1/users", query="limit=10") }}
+/// {{ build_url(host="api.example.com", query={"page": 1, "limit": 20}) }}
 /// ```
 pub fn build_url_fn(kwargs: Kwargs) -> Result<Value, Error> {
-    let scheme: String = kwargs.get("scheme")?;
+    let scheme: String = kwargs.get("scheme").unwrap_or_else(|_| "https".to_string());
     let host: String = kwargs.get("host")?;
     let port: Option<u16> = kwargs.get("port").ok();
     let path: Option<String> = kwargs.get("path").ok();
-    let query: Option<String> = kwargs.get("query").ok();
+    let query: Option<Value> = kwargs.get("query").ok();
 
     // Start with scheme and host
     let mut url = format!("{}://{}", scheme, host);
@@ -143,11 +144,48 @@ pub fn build_url_fn(kwargs: Kwargs) -> Result<Value, Error> {
     url.push_str(&path_str);
 
     // Add query string if specified
-    if let Some(q) = query
-        && !q.is_empty()
-    {
-        url.push('?');
-        url.push_str(&q);
+    if let Some(q) = query {
+        let query_str = if let Some(s) = q.as_str() {
+            // Query is a string, use it directly
+            s.to_string()
+        } else {
+            // Query is an object, serialize it using query_string logic
+            let json_value: serde_json::Value = serde_json::to_value(&q).map_err(|e| {
+                Error::new(
+                    ErrorKind::InvalidOperation,
+                    format!("Failed to convert query parameter: {}", e),
+                )
+            })?;
+
+            if !json_value.is_object() {
+                return Err(Error::new(
+                    ErrorKind::InvalidOperation,
+                    "query parameter must be a string or object",
+                ));
+            }
+
+            let mut parts = Vec::new();
+            if let Some(obj) = json_value.as_object() {
+                for (key, value) in obj {
+                    let encoded_key = urlencoding::encode(key);
+                    let value_str = match value {
+                        serde_json::Value::String(s) => s.clone(),
+                        serde_json::Value::Number(n) => n.to_string(),
+                        serde_json::Value::Bool(b) => b.to_string(),
+                        serde_json::Value::Null => String::from("null"),
+                        _ => value.to_string(),
+                    };
+                    let encoded_value = urlencoding::encode(&value_str);
+                    parts.push(format!("{}={}", encoded_key, encoded_value));
+                }
+            }
+            parts.join("&")
+        };
+
+        if !query_str.is_empty() {
+            url.push('?');
+            url.push_str(&query_str);
+        }
     }
 
     Ok(Value::from(url))

tests/integration/tests/22_url_functions.sh

@@ -75,11 +75,16 @@ assert_equals "$OUTPUT" "pass" "parse_url extracts password"
 # build_url Tests
 # ============================================================================
 
-# Test 13: Build simple URL
+# Test 13: Build simple URL with explicit scheme
 create_template "build_url_simple.tmpl" '{{ build_url(scheme="https", host="example.com") }}'
 OUTPUT=$(run_binary "build_url_simple.tmpl")
 assert_equals "$OUTPUT" "https://example.com/" "build_url creates simple URL"
 
+# Test 13b: Build simple URL with default scheme (https)
+create_template "build_url_default_scheme.tmpl" '{{ build_url(host="example.com") }}'
+OUTPUT=$(run_binary "build_url_default_scheme.tmpl")
+assert_equals "$OUTPUT" "https://example.com/" "build_url uses https as default scheme"
+
 # Test 14: Build URL with port
 create_template "build_url_port.tmpl" '{{ build_url(scheme="https", host="example.com", port=8080) }}'
 OUTPUT=$(run_binary "build_url_port.tmpl")
@@ -154,11 +159,18 @@ assert_equals "$OUTPUT" "" "query_string returns empty string for empty object"
 # Combined use cases
 # ============================================================================
 
-# Test 26: Build URL with query_string
+# Test 26: Build URL with query_string function
 create_template "combined_build_query.tmpl" '{% set params = {"page": 1, "limit": 10} %}{{ build_url(scheme="https", host="api.example.com", path="/users", query=query_string(params=params)) }}'
 OUTPUT=$(run_binary "combined_build_query.tmpl")
 assert_contains "$OUTPUT" "https://api.example.com/users?" "combined build_url with query_string"
 
+# Test 26b: Build URL with query object directly
+create_template "build_url_query_object.tmpl" '{% set params = {"page": 1, "limit": 10} %}{{ build_url(host="api.example.com", path="/users", query=params) }}'
+OUTPUT=$(run_binary "build_url_query_object.tmpl")
+assert_contains "$OUTPUT" "https://api.example.com/users?" "build_url accepts query as object"
+assert_contains "$OUTPUT" "page=1" "build_url query object includes page"
+assert_contains "$OUTPUT" "limit=10" "build_url query object includes limit"
+
 # Test 27: Parse and rebuild URL
 create_template "combined_parse_build.tmpl" '{% set original = parse_url(url="https://example.com:8080/api") %}{{ build_url(scheme=original.scheme, host=original.host, port=original.port, path=original.path) }}'
 OUTPUT=$(run_binary "combined_parse_build.tmpl")

tests/test_url_functions.rs

@@ -346,13 +346,14 @@ fn test_build_url_http_scheme() {
 }
 
 #[test]
-fn test_build_url_missing_scheme() {
+fn test_build_url_default_scheme() {
     let result = url::build_url_fn(Kwargs::from_iter(vec![(
         "host",
         Value::from("example.com"),
-    )]));
+    )]))
+    .unwrap();
 
-    assert!(result.is_err());
+    assert_eq!(result.to_string(), "https://example.com/");
 }
 
 #[test]
@@ -362,6 +363,44 @@ fn test_build_url_missing_host() {
     assert!(result.is_err());
 }
 
+#[test]
+fn test_build_url_with_query_object() {
+    let mut params = BTreeMap::new();
+    params.insert("page".to_string(), Value::from(1));
+    params.insert("limit".to_string(), Value::from(20));
+
+    let result = url::build_url_fn(Kwargs::from_iter(vec![
+        ("host", Value::from("api.example.com")),
+        ("path", Value::from("/users")),
+        ("query", Value::from_object(params)),
+    ]))
+    .unwrap();
+
+    let output = result.to_string();
+    assert!(output.starts_with("https://api.example.com/users?"));
+    assert!(output.contains("page=1"));
+    assert!(output.contains("limit=20"));
+}
+
+#[test]
+fn test_build_url_with_query_object_complex() {
+    let mut params = BTreeMap::new();
+    params.insert("search".to_string(), Value::from("hello world"));
+    params.insert("active".to_string(), Value::from(true));
+    params.insert("count".to_string(), Value::from(42));
+
+    let result = url::build_url_fn(Kwargs::from_iter(vec![
+        ("host", Value::from("example.com")),
+        ("query", Value::from_object(params)),
+    ]))
+    .unwrap();
+
+    let output = result.to_string();
+    assert!(output.contains("active=true"));
+    assert!(output.contains("count=42"));
+    assert!(output.contains("search=hello") || output.contains("search=hello%20world"));
+}
+
 // ============================================================================
 // query_string Tests
 // ============================================================================