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())
}
}