fader_master/config/src/document.rs

216 lines
7.6 KiB
Rust

use std::str::FromStr;
use toml_edit::{Array, DocumentMut, InlineTable, Item, Table, Value, value};
use crate::{ConfigError, Profile, SelectorField, TargetKind};
/// Match expression used when creating an application selector.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum SelectorPattern {
Exact(String),
Regex(String),
}
/// Editable selector input for a virtual application.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct SelectorDraft {
pub field: SelectorField,
pub pattern: SelectorPattern,
}
/// A comment-preserving profile edit that is revalidated before use.
pub struct ProfileDocument {
document: DocumentMut,
}
impl ProfileDocument {
/// Parses both the editable TOML representation and semantic profile.
pub fn parse(input: &str) -> Result<Self, ConfigError> {
Profile::parse(input)?;
let document = DocumentMut::from_str(input)?;
Ok(Self { document })
}
/// Changes one application's display label without rebuilding its table.
pub fn set_application_label(
&mut self,
application_id: &str,
label: &str,
) -> Result<(), ConfigError> {
self.transaction(|document| {
let applications = document
.get_mut("applications")
.and_then(Item::as_array_of_tables_mut)
.ok_or_else(|| {
ConfigError::validation("applications", "missing application array")
})?;
let Some(application) = applications.iter_mut().find(|table| {
table
.get("id")
.and_then(Item::as_str)
.is_some_and(|id| id == application_id)
}) else {
return Err(ConfigError::validation(
"applications",
format!("unknown application {application_id:?}"),
));
};
let existing = application
.get_mut("label")
.and_then(Item::as_value_mut)
.ok_or_else(|| {
ConfigError::validation("applications.label", "missing string label")
})?;
let decor = existing.decor().clone();
let mut replacement = Value::from(label);
*replacement.decor_mut() = decor;
*existing = replacement;
Ok(())
})
}
/// Adds a virtual application and validates the whole resulting profile.
pub fn add_application(
&mut self,
id: &str,
label: &str,
selectors: &[SelectorDraft],
) -> Result<(), ConfigError> {
self.transaction(|document| {
let applications = document
.get_mut("applications")
.and_then(Item::as_array_of_tables_mut)
.ok_or_else(|| {
ConfigError::validation("applications", "missing application array")
})?;
let mut table = Table::new();
table["id"] = value(id);
table["label"] = value(label);
let mut selector_values = Array::new();
for selector in selectors {
let mut inline = InlineTable::new();
inline.insert("field", Value::from(selector.field.as_str()));
match &selector.pattern {
SelectorPattern::Exact(pattern) => {
inline.insert("exact", Value::from(pattern.as_str()));
}
SelectorPattern::Regex(pattern) => {
inline.insert("regex", Value::from(pattern.as_str()));
}
}
selector_values.push(Value::InlineTable(inline));
}
table["selectors"] = value(selector_values);
applications.push(table);
Ok(())
})
}
/// Removes an application only when no remaining object references it.
pub fn remove_application(&mut self, id: &str) -> Result<(), ConfigError> {
self.transaction(|document| {
let applications = document
.get_mut("applications")
.and_then(Item::as_array_of_tables_mut)
.ok_or_else(|| {
ConfigError::validation("applications", "missing application array")
})?;
let index = applications
.iter()
.position(|table| table.get("id").and_then(Item::as_str) == Some(id))
.ok_or_else(|| {
ConfigError::validation("applications", format!("unknown application {id:?}"))
})?;
applications.remove(index);
Ok(())
})
}
/// Adds an absolute group and validates all member references.
pub fn add_group(
&mut self,
id: &str,
label: &str,
members: &[&str],
) -> Result<(), ConfigError> {
self.transaction(|document| {
let groups = document
.get_mut("groups")
.and_then(Item::as_array_of_tables_mut)
.ok_or_else(|| ConfigError::validation("groups", "missing group array"))?;
let mut table = Table::new();
table["id"] = value(id);
table["label"] = value(label);
let mut member_values = Array::new();
for member in members {
member_values.push(*member);
}
table["members"] = value(member_values);
table["volume_mode"] = value("absolute");
groups.push(table);
Ok(())
})
}
/// Adds a logical fader and validates its target.
pub fn add_fader(
&mut self,
id: &str,
target_kind: TargetKind,
target_id: &str,
pickup: bool,
pickup_tolerance: f64,
) -> Result<(), ConfigError> {
self.transaction(|document| {
let faders = document
.get_mut("faders")
.and_then(Item::as_array_of_tables_mut)
.ok_or_else(|| ConfigError::validation("faders", "missing fader array"))?;
let mut table = Table::new();
table["id"] = value(id);
let mut target = InlineTable::new();
let kind = match target_kind {
TargetKind::Application => "application",
TargetKind::Group => "group",
TargetKind::Output => "output",
};
target.insert("kind", Value::from(kind));
target.insert("id", Value::from(target_id));
table["target"] = value(target);
table["pickup"] = value(pickup);
table["pickup_tolerance"] = value(pickup_tolerance);
faders.push(table);
Ok(())
})
}
/// Returns the current source without consuming the draft.
#[must_use]
pub fn source(&self) -> String {
self.document.to_string()
}
/// Builds a validated runtime profile without consuming the draft.
pub fn preview(&self) -> Result<Profile, ConfigError> {
Profile::parse(&self.document.to_string())
}
fn transaction(
&mut self,
edit: impl FnOnce(&mut DocumentMut) -> Result<(), ConfigError>,
) -> Result<(), ConfigError> {
let mut candidate = self.document.clone();
edit(&mut candidate)?;
Profile::parse(&candidate.to_string())?;
self.document = candidate;
Ok(())
}
/// Returns edited TOML only if the complete result remains valid.
pub fn finish(self) -> Result<String, ConfigError> {
let output = self.document.to_string();
Profile::parse(&output)?;
Ok(output)
}
}