ud 0.1.0

UpDate! — A fast, universal dependency updater.
Documentation
use crate::core::contract::Manifest;
use crate::core::model::{Constraint, Coordinate, Dependency, Edit, Span, UdError};
use toml_edit::{DocumentMut, Item, TableLike, Value};

pub struct CargoToml;

fn parse_table(table: &dyn TableLike, section: &str, deps: &mut Vec<Dependency>) {
    for (name, value) in table.iter() {
        let coordinate = Coordinate(name.to_string());

        let constraint = if let Some(v) = value.as_str() {
            Constraint(v.to_string())
        } else if let Some(v) = value.get("version").and_then(|v| v.as_str()) {
            Constraint(v.to_string())
        } else {
            continue;
        };

        let span = value.span().map(|s| Span {
            start: s.start,
            end: s.end,
        });

        deps.push(Dependency {
            coordinate,
            constraint,
            section: section.to_string(),
            source: None,
            span,
        });
    }
}

fn update_table_item(item: &mut Item, replacement: &str) {
    if let Some(inline) = item.as_inline_table_mut() {
        if let Some(v) = inline.get_mut("version") {
            let decor = v.decor().clone();
            *v = Value::from(replacement.to_string());
            *v.decor_mut() = decor;
        }
    } else if let Some(v) = item.as_value_mut() {
        let decor = v.decor().clone();
        *v = Value::from(replacement.to_string());
        *v.decor_mut() = decor;
    } else if let Some(table) = item.as_table_like_mut()
        && let Some(v) = table.get_mut("version")
    {
        if let Some(val) = v.as_value_mut() {
            let decor = val.decor().clone();
            *val = Value::from(replacement.to_string());
            *val.decor_mut() = decor;
        } else {
            *v = toml_edit::value(replacement.to_string());
        }
    }
}

fn apply_edit(doc: &mut DocumentMut, dep: &Dependency, replacement: &str) {
    let section = &dep.section;

    if section == "workspace.dependencies" {
        if let Some(table) = doc
            .get_mut("workspace")
            .and_then(|w| w.get_mut("dependencies"))
            .and_then(|v| v.as_table_like_mut())
            && let Some(item) = table.get_mut(&dep.coordinate.0)
        {
            update_table_item(item, replacement);
        }
        return;
    }

    if let Some(trimmed) = section.strip_prefix("target.") {
        if let Some(last_dot_idx) = trimmed.rfind('.') {
            let target_name = &trimmed[..last_dot_idx];
            let dep_section = &trimmed[last_dot_idx + 1..];

            if let Some(target_val) = doc
                .get_mut("target")
                .and_then(|t| t.as_table_like_mut())
                .and_then(|t| t.get_mut(target_name))
                && let Some(table) = target_val
                    .get_mut(dep_section)
                    .and_then(|v| v.as_table_like_mut())
                && let Some(item) = table.get_mut(&dep.coordinate.0)
            {
                update_table_item(item, replacement);
            }
        }
        return;
    }

    if let Some(table) = doc.get_mut(section).and_then(|v| v.as_table_like_mut())
        && let Some(item) = table.get_mut(&dep.coordinate.0)
    {
        update_table_item(item, replacement);
    }
}

impl Manifest for CargoToml {
    fn id(&self) -> &'static str {
        "cargo-toml"
    }

    fn file_names(&self) -> &'static [&'static str] {
        &["Cargo.toml"]
    }

    fn read(&self, raw: &str) -> Result<Vec<Dependency>, UdError> {
        let doc: DocumentMut = raw
            .parse()
            .map_err(|e| UdError::Parse(format!("Failed to parse Cargo.toml: {}", e)))?;

        let mut deps = Vec::new();

        for section in &["dependencies", "dev-dependencies", "build-dependencies"] {
            if let Some(table) = doc.get(section).and_then(|v| v.as_table_like()) {
                parse_table(table, section, &mut deps);
            }
        }

        if let Some(table) = doc
            .get("workspace")
            .and_then(|w| w.get("dependencies"))
            .and_then(|v| v.as_table_like())
        {
            parse_table(table, "workspace.dependencies", &mut deps);
        }

        if let Some(target_table) = doc.get("target").and_then(|t| t.as_table_like()) {
            for (target_name, target_val) in target_table.iter() {
                for section in &["dependencies", "dev-dependencies", "build-dependencies"] {
                    if let Some(table) = target_val.get(section).and_then(|v| v.as_table_like()) {
                        let full_section = format!("target.{}.{}", target_name, section);
                        parse_table(table, &full_section, &mut deps);
                    }
                }
            }
        }

        Ok(deps)
    }

    fn write_batch(&self, raw: &str, edits: &[Edit]) -> Result<String, UdError> {
        let mut doc: DocumentMut = raw
            .parse()
            .map_err(|e| UdError::Parse(format!("Failed to parse Cargo.toml: {}", e)))?;

        for edit in edits {
            apply_edit(&mut doc, edit.dep, &edit.replacement.0);
        }

        Ok(doc.to_string())
    }
}