ud 0.1.0

UpDate! — A fast, universal dependency updater.
Documentation
use crate::core::model::{Edit, Span, UdError};
use jsonc_parser::ast::{ObjectPropName, Value};
use jsonc_parser::{CollectOptions, ParseOptions, parse_to_ast};

pub struct FoundJsonProp {
    pub section: String,
    pub name: String,
    pub val: String,
    pub val_start: usize,
    pub val_end: usize,
}

pub fn walk_json_section(raw: &str, sections: &[&str]) -> Result<Vec<FoundJsonProp>, UdError> {
    let collect_opts = CollectOptions::default();
    let parse_opts = ParseOptions::default();
    let parse_res = parse_to_ast(raw, &collect_opts, &parse_opts)
        .map_err(|e| UdError::Parse(format!("Failed to parse JSON: {}", e)))?;

    let mut found = Vec::new();

    if let Some(Value::Object(root_obj)) = parse_res.value {
        for prop in &root_obj.properties {
            let prop_name = match &prop.name {
                ObjectPropName::String(s) => s.value.as_ref(),
                ObjectPropName::Word(w) => w.value,
            };
            if sections.contains(&prop_name) {
                if let Value::Object(section_obj) = &prop.value {
                    for sub_prop in &section_obj.properties {
                        let sub_name = match &sub_prop.name {
                            ObjectPropName::String(s) => s.value.to_string(),
                            ObjectPropName::Word(w) => w.value.to_string(),
                        };
                        if let Value::StringLit(str_lit) = &sub_prop.value {
                            found.push(FoundJsonProp {
                                section: prop_name.to_string(),
                                name: sub_name,
                                val: str_lit.value.to_string(),
                                val_start: str_lit.range.start,
                                val_end: str_lit.range.end,
                            });
                        }
                    }
                }
            }
        }
    }

    Ok(found)
}

pub fn compute_span(body: &str, start: usize, end: usize) -> Span {
    if body.starts_with("npm:") || body.starts_with("jsr:") {
        if let Some(last_at_idx) = body
            .char_indices()
            .filter(|&(idx, c)| idx >= 1 && c == '@')
            .map(|(idx, _)| idx)
            .last()
        {
            let version_part = &body[last_at_idx + 1..];
            let sub_path_len = version_part.find('/').unwrap_or(version_part.len());
            let constraint_start = start + 1 + last_at_idx + 1;
            let constraint_end = constraint_start + sub_path_len;
            Span {
                start: constraint_start,
                end: constraint_end,
            }
        } else {
            Span {
                start: start + 1,
                end: end - 1,
            }
        }
    } else {
        Span {
            start: start + 1,
            end: end - 1,
        }
    }
}

pub fn write_batch_json(raw: &str, edits: &[Edit]) -> Result<String, UdError> {
    let mut sorted_edits: Vec<&Edit> = edits.iter().collect();
    sorted_edits.sort_by(|a, b| {
        let a_start = a.dep.span.map(|s| s.start).unwrap_or(0);
        let b_start = b.dep.span.map(|s| s.start).unwrap_or(0);
        b_start.cmp(&a_start)
    });

    let mut content = raw.to_string();
    for edit in sorted_edits {
        if let Some(span) = edit.dep.span {
            if span.start <= span.end && span.end <= content.len() {
                let existing = &content[span.start..span.end];
                if existing != edit.dep.constraint.0 {
                    return Err(UdError::Parse(format!(
                        "Safety check failed: existing content '{}' does not match expected constraint '{}' at {:?}",
                        existing, edit.dep.constraint.0, span
                    )));
                }
                content.replace_range(span.start..span.end, &edit.replacement.0);
            } else {
                return Err(UdError::Parse(format!("Invalid span range: {:?}", span)));
            }
        }
    }

    Ok(content)
}