robinpath_modules/modules/

url_mod.rs

use robinpath::{RobinPath, Value};
use url::Url;

pub fn register(rp: &mut RobinPath) {
    rp.register_builtin("url.parse", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        match Url::parse(&s) {
            Ok(parsed) => {
                let mut obj = indexmap::IndexMap::new();
                obj.insert(
                    "protocol".to_string(),
                    Value::String(parsed.scheme().to_string()),
                );
                obj.insert(
                    "hostname".to_string(),
                    Value::String(parsed.host_str().unwrap_or("").to_string()),
                );
                obj.insert(
                    "port".to_string(),
                    match parsed.port() {
                        Some(p) => Value::Number(p as f64),
                        None => Value::Null,
                    },
                );
                obj.insert(
                    "pathname".to_string(),
                    Value::String(parsed.path().to_string()),
                );
                obj.insert(
                    "search".to_string(),
                    Value::String(
                        parsed
                            .query()
                            .map(|q| format!("?{}", q))
                            .unwrap_or_default(),
                    ),
                );
                obj.insert(
                    "hash".to_string(),
                    Value::String(
                        parsed
                            .fragment()
                            .map(|f| format!("#{}", f))
                            .unwrap_or_default(),
                    ),
                );
                Ok(Value::Object(obj))
            }
            Err(e) => Err(format!("url parse error: {}", e)),
        }
    });

    rp.register_builtin("url.format", |args, _| {
        let parts = args.first().cloned().unwrap_or(Value::Null);
        if let Value::Object(obj) = &parts {
            let protocol = obj
                .get("protocol")
                .map(|v| v.to_display_string())
                .unwrap_or_else(|| "https".to_string());
            let hostname = obj
                .get("hostname")
                .map(|v| v.to_display_string())
                .unwrap_or_default();
            let port = obj.get("port").and_then(|v| v.as_number());
            let pathname = obj
                .get("pathname")
                .map(|v| v.to_display_string())
                .unwrap_or_else(|| "/".to_string());
            let search = obj
                .get("search")
                .map(|v| v.to_display_string())
                .unwrap_or_default();
            let hash = obj
                .get("hash")
                .map(|v| v.to_display_string())
                .unwrap_or_default();

            let mut result = format!("{}://{}", protocol, hostname);
            if let Some(p) = port {
                let p = p as u16;
                result.push_str(&format!(":{}", p));
            }
            result.push_str(&pathname);
            result.push_str(&search);
            result.push_str(&hash);
            Ok(Value::String(result))
        } else {
            Err("url.format expects an object".to_string())
        }
    });

    rp.register_builtin("url.getParam", |args, _| {
        let url_str = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let param = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        match Url::parse(&url_str) {
            Ok(parsed) => {
                let value = parsed.query_pairs().find(|(k, _)| k == &param).map(|(_, v)| v.to_string());
                match value {
                    Some(v) => Ok(Value::String(v)),
                    None => Ok(Value::Null),
                }
            }
            Err(_) => Ok(Value::Null),
        }
    });

    rp.register_builtin("url.setParam", |args, _| {
        let url_str = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let param = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let value = args.get(2).map(|v| v.to_display_string()).unwrap_or_default();
        match Url::parse(&url_str) {
            Ok(mut parsed) => {
                // Remove existing param and add new one
                let pairs: Vec<(String, String)> = parsed
                    .query_pairs()
                    .filter(|(k, _)| k != &param)
                    .map(|(k, v)| (k.to_string(), v.to_string()))
                    .collect();
                {
                    let mut query = parsed.query_pairs_mut();
                    query.clear();
                    for (k, v) in &pairs {
                        query.append_pair(k, v);
                    }
                    query.append_pair(&param, &value);
                }
                Ok(Value::String(parsed.to_string()))
            }
            Err(e) => Err(format!("url parse error: {}", e)),
        }
    });

    rp.register_builtin("url.removeParam", |args, _| {
        let url_str = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let param = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        match Url::parse(&url_str) {
            Ok(mut parsed) => {
                let pairs: Vec<(String, String)> = parsed
                    .query_pairs()
                    .filter(|(k, _)| k != &param)
                    .map(|(k, v)| (k.to_string(), v.to_string()))
                    .collect();
                {
                    let mut query = parsed.query_pairs_mut();
                    query.clear();
                    for (k, v) in &pairs {
                        query.append_pair(k, v);
                    }
                }
                // Remove trailing ? if no params left
                if parsed.query() == Some("") {
                    parsed.set_query(None);
                }
                Ok(Value::String(parsed.to_string()))
            }
            Err(e) => Err(format!("url parse error: {}", e)),
        }
    });

    rp.register_builtin("url.getParams", |args, _| {
        let url_str = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        match Url::parse(&url_str) {
            Ok(parsed) => {
                let mut obj = indexmap::IndexMap::new();
                for (k, v) in parsed.query_pairs() {
                    obj.insert(k.to_string(), Value::String(v.to_string()));
                }
                Ok(Value::Object(obj))
            }
            Err(_) => Ok(Value::Object(indexmap::IndexMap::new())),
        }
    });

    rp.register_builtin("url.isValid", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::Bool(Url::parse(&s).is_ok()))
    });

    rp.register_builtin("url.encode", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::String(percent_encode(&s)))
    });

    rp.register_builtin("url.decode", |args, _| {
        let s = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::String(percent_decode(&s)))
    });
}

fn percent_encode(s: &str) -> String {
    let mut result = String::new();
    for byte in s.bytes() {
        match byte {
            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
                result.push(byte as char);
            }
            _ => {
                result.push_str(&format!("%{:02X}", byte));
            }
        }
    }
    result
}

fn percent_decode(s: &str) -> String {
    let mut result = Vec::new();
    let bytes = s.as_bytes();
    let mut i = 0;
    while i < bytes.len() {
        if bytes[i] == b'%' && i + 2 < bytes.len() {
            if let Ok(byte) = u8::from_str_radix(
                &String::from_utf8_lossy(&bytes[i + 1..i + 3]),
                16,
            ) {
                result.push(byte);
                i += 3;
                continue;
            }
        }
        result.push(bytes[i]);
        i += 1;
    }
    String::from_utf8_lossy(&result).to_string()
}