use crate::registry_core::authoring::validation::rust_string;
use crate::registry_core::declaration::OwnedFlowContract;
use crate::registry_core::syntax::nesting::guard_nesting;
use super::FaceParseError;
struct CompactFlow<'a> {
id: &'a str,
version: u32,
input: &'a str,
output: &'a str,
}
fn parse_compact_flow(value: &str) -> Result<Option<CompactFlow<'_>>, FaceParseError> {
let value = value.trim();
if value.is_empty() || value.eq_ignore_ascii_case("none") {
return Ok(None);
}
let mut fields = value.split('|');
let id = fields.next().unwrap_or_default().trim();
let version = fields.next().unwrap_or_default().trim();
let input = fields.next().unwrap_or_default().trim();
let output = fields.next().unwrap_or_default().trim();
if fields.next().is_some() || id.is_empty() || input.is_empty() || output.is_empty() {
return Err("flow must use id|version|input|output syntax"
.to_owned()
.into());
}
let version = version
.parse::<u32>()
.map_err(|_| "flow version must be an unsigned integer".to_owned())?;
Ok(Some(CompactFlow {
id,
version,
input,
output,
}))
}
pub fn render_flow_expression(value: &str) -> Result<String, FaceParseError> {
let expression = flow_contract_expression(value)?;
if expression.is_empty() {
return Ok(String::new());
}
Ok(format!(" flow: {expression},\n"))
}
pub fn flow_contract_expression(value: &str) -> Result<String, FaceParseError> {
let Some(flow) = parse_compact_flow(value)? else {
return Ok(String::new());
};
Ok(format!(
"crate::FlowContract::new(crate::ContractId::new(\"{}\"), {}, \"{}\", \"{}\")",
rust_string(flow.id),
flow.version,
rust_string(flow.input),
rust_string(flow.output),
))
}
pub fn parse_flow_value(value: &str) -> Result<Option<OwnedFlowContract>, FaceParseError> {
Ok(parse_compact_flow(value)?.map(|flow| OwnedFlowContract {
id: flow.id.to_owned(),
version: flow.version,
input: flow.input.to_owned(),
output: flow.output.to_owned(),
}))
}
pub fn render_flow_provider(value: &str) -> Result<String, FaceParseError> {
let value = value.trim();
if value.is_empty() {
return Ok(String::new());
}
guard_nesting(value).map_err(|error| FaceParseError::new(error.to_string()))?;
syn::parse_str::<syn::Path>(value)
.map_err(|_| "flow_provider must be a Rust type path".to_owned())?;
Ok(format!(" flow_provider: {value},\n"))
}
pub fn parse_flow_field(value: &str) -> Result<String, FaceParseError> {
let trimmed = value.trim();
if trimmed.is_empty() {
return Ok(String::new());
}
if let Ok(compact) = parse_flow_expression(trimmed) {
return Ok(compact);
}
if parse_compact_flow(trimmed)?.is_some() {
return Ok(trimmed.to_owned());
}
Ok(String::new())
}
pub fn parse_flow_expression(value: &str) -> Result<String, FaceParseError> {
let value = value.trim();
if value.is_empty() || value.ends_with("FlowContract::NONE") {
return Ok(String::new());
}
guard_nesting(value).map_err(|error| FaceParseError::new(error.to_string()))?;
let expression = syn::parse_str::<syn::Expr>(value)
.map_err(|_| "generated face has an invalid flow expression".to_owned())?;
let syn::Expr::Call(call) = expression else {
return Err("generated face has an invalid flow expression"
.to_owned()
.into());
};
if !path_ends_with(&call.func, "FlowContract::new") || call.args.len() != 4 {
return Err("generated face has an invalid flow expression"
.to_owned()
.into());
}
let mut args = call.args.iter();
let id_call = args
.next()
.ok_or_else(|| "generated face has an invalid flow id".to_owned())?;
let syn::Expr::Call(id_call) = id_call else {
return Err("generated face has an invalid flow id".to_owned().into());
};
if !path_ends_with(&id_call.func, "ContractId::new") || id_call.args.len() != 1 {
return Err("generated face has an invalid flow id".to_owned().into());
}
let id = literal_string_expr(
id_call
.args
.first()
.ok_or_else(|| "generated face has an invalid flow id".to_owned())?,
)?;
let version = match args
.next()
.ok_or_else(|| "generated face has an invalid flow version".to_owned())?
{
syn::Expr::Lit(literal) => match &literal.lit {
syn::Lit::Int(value) => value
.base10_parse::<u32>()
.map_err(|_| "generated face has an invalid flow version".to_owned())?,
_ => {
return Err("generated face has an invalid flow version"
.to_owned()
.into());
}
},
_ => {
return Err("generated face has an invalid flow version"
.to_owned()
.into());
}
};
let input = literal_string_expr(
args.next()
.ok_or_else(|| "generated face has an invalid flow input".to_owned())?,
)?;
let output = literal_string_expr(
args.next()
.ok_or_else(|| "generated face has an invalid flow output".to_owned())?,
)?;
Ok(format!("{id}|{version}|{input}|{output}"))
}
pub fn path_ends_with(expression: &syn::Expr, suffix: &str) -> bool {
let syn::Expr::Path(path) = expression else {
return false;
};
let actual = path
.path
.segments
.iter()
.map(|segment| segment.ident.to_string())
.collect::<Vec<_>>()
.join("::");
actual.ends_with(suffix)
}
pub fn literal_string_expr(expression: &syn::Expr) -> Result<String, FaceParseError> {
let syn::Expr::Lit(literal) = expression else {
return Err("generated face expects a string literal".to_owned().into());
};
let syn::Lit::Str(value) = &literal.lit else {
return Err("generated face expects a string literal".to_owned().into());
};
Ok(value.value())
}
#[cfg(test)]
mod tests {
use super::{parse_flow_value, render_flow_expression};
use crate::registry_core::declaration::OwnedFlowContract;
#[test]
fn flow_render_and_parse_read_one_parser() {
for malformed in ["id|1|in", "id|1|in|out|extra", "|1|in|out", "id|x|in|out"] {
let rendered = render_flow_expression(malformed).unwrap_err();
let parsed = parse_flow_value(malformed).unwrap_err();
assert_eq!(rendered, parsed, "value `{malformed}`");
}
assert_eq!(
render_flow_expression(" render.v1 | 2 | LocalCoordinates | CanvasFrame ").unwrap(),
" flow: crate::FlowContract::new(crate::ContractId::new(\"render.v1\"), 2, \"LocalCoordinates\", \"CanvasFrame\"),\n"
);
assert_eq!(
parse_flow_value(" render.v1 | 2 | LocalCoordinates | CanvasFrame ").unwrap(),
Some(OwnedFlowContract {
id: "render.v1".to_owned(),
version: 2,
input: "LocalCoordinates".to_owned(),
output: "CanvasFrame".to_owned(),
})
);
assert!(render_flow_expression("none").unwrap().is_empty());
assert!(render_flow_expression(" ").unwrap().is_empty());
assert_eq!(parse_flow_value("NONE").unwrap(), None);
assert_eq!(parse_flow_value("").unwrap(), None);
}
}
#[cfg(test)]
#[path = "flow_tests.rs"]
mod flow_tests;
#[test]
fn a_compact_flow_field_reads_back_as_the_same_compact_value() {
let compact = "panel.render.v1|1|PanelInput|PanelFrame";
assert_eq!(
parse_flow_field(compact).expect("the editor's own form is accepted"),
compact,
"the compact form comes back unchanged"
);
let expression = "crate::FlowContract::new(crate::ContractId::new(\"panel.render.v1\"), 1, \"PanelInput\", \"PanelFrame\")";
assert_eq!(
parse_flow_field(expression).expect("a literal face's expression is accepted"),
compact,
"the Rust expression normalizes to the same compact value"
);
assert_eq!(parse_flow_field("").expect("empty is legal"), "");
}