ud 0.1.0

UpDate! — A fast, universal dependency updater.
Documentation
use crate::core::contract::Manifest;
use crate::core::model::{Constraint, Coordinate, Dependency, Edit, UdError};
use crate::ecosystems::web::json_walk::{compute_span, walk_json_section, write_batch_json};
use crate::ecosystems::web::specifier::{is_checkable_constraint, parse_specifier};

pub struct DenoJson;

impl Manifest for DenoJson {
    fn id(&self) -> &'static str {
        "deno-json"
    }

    fn file_names(&self) -> &'static [&'static str] {
        &["deno.json", "deno.jsonc"]
    }

    fn read(&self, raw: &str) -> Result<Vec<Dependency>, UdError> {
        let props = walk_json_section(raw, &["imports"])?;
        let mut deps = Vec::new();

        for prop in props {
            let val = prop.val.trim();
            if val.starts_with("jsr:") || val.starts_with("npm:") {
                if let Some(parsed) = parse_specifier(val) {
                    if is_checkable_constraint(&parsed.constraint) {
                        let span = compute_span(&prop.val, prop.val_start, prop.val_end);
                        deps.push(Dependency {
                            coordinate: Coordinate(parsed.coordinate),
                            constraint: Constraint(parsed.constraint),
                            section: "imports".to_string(),
                            source: Some(parsed.registry),
                            span: Some(span),
                        });
                    } else {
                        tracing::debug!(
                            "Skipping deno.json import '{}': tag/no-range constraint '{}' in specifier '{}'",
                            prop.name,
                            parsed.constraint,
                            val
                        );
                    }
                } else {
                    tracing::debug!(
                        "Skipping deno.json import '{}': versionless/unsupported specifier '{}'",
                        prop.name,
                        val
                    );
                }
            }
        }

        Ok(deps)
    }

    fn write_batch(&self, raw: &str, edits: &[Edit]) -> Result<String, UdError> {
        write_batch_json(raw, edits)
    }
}