use crate::registry_core::authoring::validation::rust_string;
use crate::registry_core::declaration::{OwnedRegistrationRule, OwnedRequirementSpec};
use super::{FaceParseError, quoted_list_field, split_csv_owned};
fn quoted_value_field(text: &str, marker: &str) -> Option<String> {
let rest = text.split_once(marker)?.1;
let start = rest.find('"')? + 1;
let end = rest[start..].find('"')? + start;
Some(rest[start..end].to_owned())
}
fn rule_requiring_nothing() -> OwnedRegistrationRule {
OwnedRegistrationRule {
required_preset: None,
required_parts: Vec::new(),
required_exports: Vec::new(),
required_handle_traits: Vec::new(),
required_part_traits: Vec::new(),
}
}
pub fn compact_registration_rule(rule: &OwnedRegistrationRule) -> String {
let mut clauses = Vec::new();
if let Some(preset) = &rule.required_preset {
clauses.push(format!("preset:{preset}"));
}
for (key, values) in [
("parts", &rule.required_parts),
("exports", &rule.required_exports),
("handle", &rule.required_handle_traits),
("part_trait", &rule.required_part_traits),
] {
if !values.is_empty() {
clauses.push(format!("{key}:{}", values.join(",")));
}
}
if clauses.is_empty() {
"ANY".to_owned()
} else {
clauses.join(";")
}
}
const RULE_CONST: &str = "REGISTRATION_RULE";
pub fn try_rule_syntax_from_text(text: &str) -> Result<String, FaceParseError> {
let file = syn::parse_file(text).map_err(|error| {
FaceParseError::new(format!(
"registration-rule source does not parse as Rust: {error}"
))
})?;
let expression = file
.items
.iter()
.find_map(|item| match item {
syn::Item::Const(item) if item.ident == RULE_CONST => Some(&item.expr),
_ => None,
})
.ok_or_else(|| {
FaceParseError::new(format!(
"registration-rule source declares no `{RULE_CONST}` const"
))
})?;
Ok(compact_registration_rule(&read_rule_expression(
expression,
)?))
}
fn read_rule_expression(expression: &syn::Expr) -> Result<OwnedRegistrationRule, FaceParseError> {
match expression {
syn::Expr::Path(path)
if path
.path
.segments
.last()
.is_some_and(|segment| segment.ident == "ANY") =>
{
Ok(rule_requiring_nothing())
}
syn::Expr::Call(call) if is_builder_start(&call.func) => {
if !call.args.is_empty() {
return Err(FaceParseError::new(
"`RegistrationRule::new` takes no arguments".to_owned(),
));
}
Ok(rule_requiring_nothing())
}
syn::Expr::MethodCall(call) => {
let mut rule = read_rule_expression(&call.receiver)?;
let method = call.method.to_string();
match method.as_str() {
"require_preset" => {
rule.required_preset = Some(single_string_argument(&call.args, &method)?);
}
"require_parts" => rule.required_parts = string_list_argument(&call.args, &method)?,
"require_exports" => {
rule.required_exports = string_list_argument(&call.args, &method)?;
}
"require_handle_traits" => {
rule.required_handle_traits = string_list_argument(&call.args, &method)?;
}
"require_part_traits" => {
rule.required_part_traits = string_list_argument(&call.args, &method)?;
}
other => {
return Err(FaceParseError::new(format!(
"unknown registration-rule clause `.{other}(…)`; the reader only knows the `require_*` calls the renderer emits"
)));
}
}
Ok(rule)
}
_ => Err(FaceParseError::new(format!(
"`{RULE_CONST}` is not a `RegistrationRule` builder expression"
))),
}
}
fn is_builder_start(func: &syn::Expr) -> bool {
matches!(func, syn::Expr::Path(path)
if path.path.segments.last().is_some_and(|segment| segment.ident == "new"))
}
fn single_string_argument(
arguments: &syn::punctuated::Punctuated<syn::Expr, syn::Token![,]>,
method: &str,
) -> Result<String, FaceParseError> {
let mut arguments = arguments.iter();
let Some(syn::Expr::Lit(syn::ExprLit {
lit: syn::Lit::Str(value),
..
})) = arguments.next()
else {
return Err(FaceParseError::new(format!(
"`.{method}(…)` needs one string literal argument"
)));
};
if arguments.next().is_some() {
return Err(FaceParseError::new(format!(
"`.{method}(…)` takes exactly one argument"
)));
}
Ok(value.value())
}
fn string_list_argument(
arguments: &syn::punctuated::Punctuated<syn::Expr, syn::Token![,]>,
method: &str,
) -> Result<Vec<String>, FaceParseError> {
let mut arguments = arguments.iter();
let Some(argument) = arguments.next() else {
return Err(FaceParseError::new(format!(
"`.{method}(…)` needs one list argument"
)));
};
if arguments.next().is_some() {
return Err(FaceParseError::new(format!(
"`.{method}(…)` takes exactly one argument"
)));
}
let array = match argument {
syn::Expr::Array(array) => array,
syn::Expr::Reference(reference) => match reference.expr.as_ref() {
syn::Expr::Array(array) => array,
_ => {
return Err(FaceParseError::new(format!(
"`.{method}(…)` needs a list of string literals"
)));
}
},
_ => {
return Err(FaceParseError::new(format!(
"`.{method}(…)` needs a list of string literals"
)));
}
};
array
.elems
.iter()
.map(|element| match element {
syn::Expr::Lit(syn::ExprLit {
lit: syn::Lit::Str(value),
..
}) => Ok(value.value()),
_ => Err(FaceParseError::new(format!(
"`.{method}(…)` needs string literals in its list"
))),
})
.collect()
}
#[cfg(test)]
#[path = "rules_tests.rs"]
mod rules_tests;
pub fn rule_syntax_from_text(text: &str) -> String {
let expression = text
.split_once('=')
.map(|(_, value)| value.trim().trim_end_matches(';'))
.unwrap_or("");
if expression.contains("RegistrationRule::ANY") {
return compact_registration_rule(&rule_requiring_nothing());
}
compact_registration_rule(&OwnedRegistrationRule {
required_preset: quoted_value_field(expression, ".require_preset("),
required_parts: quoted_list_field(expression, ".require_parts("),
required_exports: quoted_list_field(expression, ".require_exports("),
required_handle_traits: quoted_list_field(expression, ".require_handle_traits("),
required_part_traits: quoted_list_field(expression, ".require_part_traits("),
})
}
pub fn render_registration_rule(value: &str) -> Result<String, FaceParseError> {
let value = value.trim();
if value.is_empty() || value.eq_ignore_ascii_case("any") {
return Ok("crate::RegistrationRule::ANY".to_owned());
}
let rule = parse_registration_rule_owned(value)?;
let render_values = |values: &[String]| {
values
.iter()
.map(|value| format!("\"{}\"", rust_string(value)))
.collect::<Vec<_>>()
.join(", ")
};
let mut expression = "crate::RegistrationRule::new()".to_owned();
if let Some(preset) = rule.required_preset {
expression.push_str(&format!(".require_preset(\"{}\")", rust_string(&preset)));
}
for (method, values) in [
("require_parts", &rule.required_parts),
("require_exports", &rule.required_exports),
("require_handle_traits", &rule.required_handle_traits),
("require_part_traits", &rule.required_part_traits),
] {
if !values.is_empty() {
expression.push_str(&format!(".{method}(&[{}])", render_values(values)));
}
}
Ok(expression)
}
#[deprecated(
note = "lossy: malformed `requires` entries are dropped silently; use `try_render_requirements`"
)]
pub fn render_requirements(value: &str) -> String {
value
.split(',')
.filter_map(|item| requirement_item(item).ok())
.map(rendered_requirement)
.collect::<Vec<_>>()
.join(", ")
}
pub fn try_render_requirements(value: &str) -> Result<String, FaceParseError> {
value
.split(',')
.filter(|item| !item.trim().is_empty())
.map(|item| requirement_item(item).map(rendered_requirement))
.collect::<Result<Vec<_>, _>>()
.map(|rows| rows.join(", "))
}
fn rendered_requirement(requirement: OwnedRequirementSpec) -> String {
format!(
"\"{}\" => \"{}\"",
rust_string(&requirement.capability),
rust_string(&requirement.provider)
)
}
pub fn parse_requirements_snapshot(value: &str) -> Vec<OwnedRequirementSpec> {
value
.split(',')
.filter_map(|item| requirement_item(item).ok())
.collect()
}
pub fn parse_requirements_owned(value: &str) -> Vec<OwnedRequirementSpec> {
parse_requirements_snapshot(value)
}
pub fn try_parse_requirements_owned(
value: &str,
) -> Result<Vec<OwnedRequirementSpec>, FaceParseError> {
value
.split(',')
.filter(|item| !item.trim().is_empty())
.map(requirement_item)
.collect()
}
fn requirement_item(item: &str) -> Result<OwnedRequirementSpec, FaceParseError> {
let item = item.trim();
let (capability, provider) = item.split_once("=>").ok_or_else(|| {
FaceParseError::from("requires entries must use capability=>provider syntax".to_owned())
})?;
if capability.trim().is_empty() || provider.trim().is_empty() {
return Err("requires entries cannot be empty".to_owned().into());
}
Ok(OwnedRequirementSpec {
capability: capability.trim().to_owned(),
provider: provider.trim().to_owned(),
})
}
pub fn parse_requirements(value: &str) -> Result<(), FaceParseError> {
try_parse_requirements_owned(value).map(|_| ())
}
pub fn parse_registration_rule_snapshot(
value: &str,
) -> Result<OwnedRegistrationRule, FaceParseError> {
let value = value.trim();
if value.is_empty() || value.eq_ignore_ascii_case("any") {
return Ok(rule_requiring_nothing());
}
let mut rule = rule_requiring_nothing();
for clause in value
.split(';')
.map(str::trim)
.filter(|clause| !clause.is_empty())
{
let (key, body) = clause
.split_once(':')
.ok_or_else(|| "registration_rule clauses must use key:value syntax".to_owned())?;
let values = split_csv_owned(body);
if values.is_empty() && key.trim() != "preset" {
return Err("registration_rule clauses must list at least one value"
.to_owned()
.into());
}
match key.trim().to_ascii_lowercase().as_str() {
"parts" => rule.required_parts.extend(values),
"exports" => rule.required_exports.extend(values),
"handle" | "handle_trait" | "handle_traits" => {
rule.required_handle_traits.extend(values)
}
"part_trait" | "part_traits" => rule.required_part_traits.extend(values),
"preset" if body.trim().is_empty() => {
return Err("registration_rule preset cannot be empty".to_owned().into());
}
"preset" => rule.required_preset = Some(body.trim().to_owned()),
key => return Err(format!("unknown registration_rule clause `{key}`").into()),
}
}
Ok(rule)
}
pub fn parse_registration_rule_owned(value: &str) -> Result<OwnedRegistrationRule, FaceParseError> {
parse_registration_rule_snapshot(value)
}
#[cfg(test)]
mod tests {
use super::{parse_registration_rule_owned, render_registration_rule};
#[test]
fn registration_rules_only_describe_minimum_structure() {
let rule = parse_registration_rule_owned(
"preset:ActionParts;parts:paint;exports:control.render;handle:ControlHandle;part_trait:ActionParts",
)
.unwrap();
assert_eq!(rule.required_preset.as_deref(), Some("ActionParts"));
assert_eq!(rule.required_parts, ["paint"]);
assert_eq!(rule.required_exports, ["control.render"]);
assert_eq!(rule.required_handle_traits, ["ControlHandle"]);
assert_eq!(rule.required_part_traits, ["ActionParts"]);
let source = render_registration_rule(
"preset:ActionParts;parts:paint;exports:control.render;handle:ControlHandle;part_trait:ActionParts",
)
.unwrap();
assert!(source.contains("RegistrationRule::new()"));
assert!(source.contains("require_parts(&[\"paint\"])"));
assert!(!source.contains("allow"));
}
#[test]
fn kind_filters_are_not_registration_rules() {
let error = parse_registration_rule_owned("allow:Button").unwrap_err();
assert!(
error
.to_string()
.contains("unknown registration_rule clause `allow`"),
"{error}"
);
}
}