canic_host/response_parse/

mod.rs

pub const RECORD_MARKER: &str = "record {";

#[cfg(test)]
mod tests;

#[must_use]
pub fn find_field<'a>(value: &'a serde_json::Value, field: &str) -> Option<&'a serde_json::Value> {
    match value {
        serde_json::Value::Object(map) => map
            .get(field)
            .or_else(|| map.values().find_map(|value| find_field(value, field))),
        serde_json::Value::Array(values) => {
            values.iter().find_map(|value| find_field(value, field))
        }
        _ => None,
    }
}

#[must_use]
pub fn find_string_field(value: &serde_json::Value, field: &str) -> Option<String> {
    match value {
        serde_json::Value::Object(map) => map
            .get(field)
            .and_then(|value| value.as_str().map(ToString::to_string))
            .or_else(|| {
                map.values()
                    .find_map(|value| find_string_field(value, field))
            }),
        serde_json::Value::Array(values) => values
            .iter()
            .find_map(|value| find_string_field(value, field)),
        _ => None,
    }
}

#[must_use]
pub fn response_candid(value: &serde_json::Value) -> Option<&str> {
    find_field(value, "response_candid").and_then(serde_json::Value::as_str)
}

#[must_use]
pub fn parse_candid_text_field(output: &str, field: &str) -> Option<String> {
    let after_eq = field_value_after_equals(output, field)?;
    let after_quote = after_eq.trim_start().strip_prefix('"')?;
    parse_candid_quoted_text(after_quote)
}

#[must_use]
pub fn parse_candid_text_like_field(output: &str, field: &str) -> Option<String> {
    let after_eq = field_value_after_equals(output, field)?;
    let after_quote = after_eq
        .trim_start()
        .strip_prefix("opt \"")
        .or_else(|| after_eq.trim_start().strip_prefix('"'))?;
    parse_candid_quoted_text(after_quote)
}

#[must_use]
pub fn parse_cycle_balance_response(output: &str) -> Option<u128> {
    serde_json::from_str::<serde_json::Value>(output)
        .ok()
        .and_then(|value| {
            find_field(&value, "Ok")
                .and_then(parse_json_u128)
                .or_else(|| response_candid(&value).and_then(parse_cycle_balance_candid))
        })
        .or_else(|| parse_cycle_balance_candid(output))
}

fn parse_cycle_balance_candid(output: &str) -> Option<u128> {
    output
        .split_once('=')
        .map_or(output, |(_, cycles)| cycles)
        .lines()
        .find_map(parse_leading_u128_digits)
}

fn parse_candid_quoted_text(text_after_quote: &str) -> Option<String> {
    let mut value = String::new();
    let mut escaped = false;
    for ch in text_after_quote.chars() {
        if escaped {
            value.push(ch);
            escaped = false;
            continue;
        }
        if ch == '\\' {
            escaped = true;
            continue;
        }
        if ch == '"' {
            return Some(value);
        }
        value.push(ch);
    }
    None
}

#[must_use]
pub fn parse_json_u64(value: &serde_json::Value) -> Option<u64> {
    value
        .as_u64()
        .or_else(|| value.as_str().and_then(parse_u64_digits))
}

#[must_use]
pub fn parse_json_u128(value: &serde_json::Value) -> Option<u128> {
    value
        .as_u64()
        .map(u128::from)
        .or_else(|| value.as_str().and_then(parse_u128_digits))
}

#[must_use]
pub fn field_value_after_equals<'a>(text: &'a str, field: &str) -> Option<&'a str> {
    let (_, after_field) = text.split_once(field)?;
    let (_, after_eq) = after_field.split_once('=')?;
    Some(after_eq.trim_start())
}

#[must_use]
pub fn text_after<'a>(text: &'a str, marker: &str) -> Option<&'a str> {
    let (_, after_marker) = text.split_once(marker)?;
    Some(after_marker.trim_start())
}

#[must_use]
pub fn parse_u64_digits(text: &str) -> Option<u64> {
    number_digits(text).parse().ok()
}

#[must_use]
pub fn parse_u128_digits(text: &str) -> Option<u128> {
    number_digits(text).parse().ok()
}

#[must_use]
fn parse_leading_u128_digits(text: &str) -> Option<u128> {
    leading_number_digits(text).parse().ok()
}

#[must_use]
pub fn quoted_strings(text: &str) -> Vec<String> {
    let mut values = Vec::new();
    let mut remaining = text;
    while let Some((_, after_open)) = remaining.split_once('"') {
        let Some((value, after_close)) = after_open.split_once('"') else {
            break;
        };
        values.push(value.to_string());
        remaining = after_close;
    }
    values
}

#[must_use]
pub fn candid_record_blocks(text: &str) -> Vec<&str> {
    let mut blocks = Vec::new();
    let mut index = 0;
    while let Some(relative_start) = text[index..].find(RECORD_MARKER) {
        let start = index + relative_start;
        let mut depth = 1_u32;
        let mut cursor = start + RECORD_MARKER.len();
        let bytes = text.as_bytes();
        while cursor < text.len() {
            match bytes[cursor] {
                b'{' => depth = depth.saturating_add(1),
                b'}' => {
                    depth = depth.saturating_sub(1);
                    if depth == 0 {
                        let end = cursor + 1;
                        blocks.push(&text[start..end]);
                        index = start + RECORD_MARKER.len();
                        break;
                    }
                }
                _ => {}
            }
            cursor += 1;
        }
        if depth != 0 {
            break;
        }
    }
    blocks
}

fn number_digits(text: &str) -> String {
    text.chars()
        .skip_while(|ch| !ch.is_ascii_digit())
        .take_while(|ch| ch.is_ascii_digit() || *ch == '_' || *ch == ',')
        .filter(char::is_ascii_digit)
        .collect()
}

fn leading_number_digits(text: &str) -> String {
    text.trim_start_matches(|ch: char| ch == '(' || ch.is_whitespace())
        .chars()
        .take_while(|ch| ch.is_ascii_digit() || *ch == '_' || *ch == ',')
        .filter(char::is_ascii_digit)
        .collect()
}