use crate::registry_core::authoring::validation::rust_string;
use crate::registry_core::declaration::OwnedAdmission;
use super::{FaceParseError, quoted_list_field, split_csv_owned};
pub fn compact_admission(admission: &OwnedAdmission) -> String {
let (allow, deny) = (&admission.allowed_paths, &admission.denied_paths);
match (allow.is_empty(), deny.is_empty()) {
(true, true) => "ANY".to_owned(),
(false, true) => format!("allow:{}", allow.join(",")),
(true, false) => format!("deny:{}", deny.join(",")),
(false, false) => format!("allow:{};deny:{}", allow.join(","), deny.join(",")),
}
}
pub fn parse_admission_expression(expression: &str) -> Result<String, FaceParseError> {
let expression = expression.trim().trim_end_matches(',');
let policy = |allowed_paths, denied_paths| {
compact_admission(&OwnedAdmission {
allowed_paths,
denied_paths,
})
};
if expression.is_empty() || expression.contains("Admission::ANY") {
return Ok(policy(Vec::new(), Vec::new()));
}
let paths = quoted_list_field(expression, "allow_paths(");
if !paths.is_empty() {
return Ok(policy(paths, Vec::new()));
}
let paths = quoted_list_field(expression, "deny_paths(");
if !paths.is_empty() {
return Ok(policy(Vec::new(), paths));
}
if let Some((_, rest)) = expression.split_once("Admission::new(") {
let mut parts = rest.split(']');
let allow = parts.next().map(read_string_literals).unwrap_or_default();
let deny = parts.next().map(read_string_literals).unwrap_or_default();
return Ok(policy(allow, deny));
}
Err("generated face has an invalid admission expression"
.to_owned()
.into())
}
fn read_string_literals(fragment: &str) -> Vec<String> {
let fragment = fragment.rsplit_once('[').map_or(fragment, |(_, rest)| rest);
fragment
.split(',')
.filter_map(|value| {
let value = value.trim().trim_end_matches(']').trim();
value
.strip_prefix('"')
.and_then(|value| value.strip_suffix('"'))
.map(str::to_owned)
})
.collect()
}
struct CompactAdmission {
allowed_paths: Vec<String>,
denied_paths: Vec<String>,
}
fn admission_syntax_error() -> FaceParseError {
"admission must be ANY, allow:path/prefix, deny:path/prefix, or allow:…;deny:…"
.to_owned()
.into()
}
fn parse_compact_admission(value: &str) -> Result<Option<CompactAdmission>, FaceParseError> {
let value = value.trim();
if value.is_empty() || value.eq_ignore_ascii_case("any") {
return Ok(None);
}
let clauses = value
.split(';')
.map(str::trim)
.filter(|clause| !clause.is_empty())
.collect::<Vec<_>>();
if clauses.is_empty() {
return Err(admission_syntax_error());
}
let mut allowed_paths = Vec::new();
let mut denied_paths = Vec::new();
for clause in clauses {
let (key, paths) = clause.split_once(':').ok_or_else(admission_syntax_error)?;
let paths = split_csv_owned(paths);
if paths.is_empty() {
return Err("admission must list at least one path".to_owned().into());
}
match key.trim().to_ascii_lowercase().as_str() {
"allow" if !allowed_paths.is_empty() => {
return Err("admission names `allow` twice".to_owned().into());
}
"deny" if !denied_paths.is_empty() => {
return Err("admission names `deny` twice".to_owned().into());
}
"allow" => allowed_paths = paths,
"deny" => denied_paths = paths,
_ => return Err(admission_syntax_error()),
}
}
Ok(Some(CompactAdmission {
allowed_paths,
denied_paths,
}))
}
pub fn parse_admission_snapshot(value: &str) -> Result<OwnedAdmission, FaceParseError> {
Ok(match parse_compact_admission(value)? {
None => OwnedAdmission {
allowed_paths: Vec::new(),
denied_paths: Vec::new(),
},
Some(admission) => OwnedAdmission {
allowed_paths: admission.allowed_paths,
denied_paths: admission.denied_paths,
},
})
}
pub fn parse_admission_owned(value: &str) -> Result<OwnedAdmission, FaceParseError> {
parse_admission_snapshot(value)
}
pub fn render_admission(value: &str) -> Result<String, FaceParseError> {
let Some(admission) = parse_compact_admission(value)? else {
return Ok("crate::Admission::ANY".to_owned());
};
let quoted = |paths: &[String]| {
paths
.iter()
.map(|path| format!("\"{}\"", rust_string(path)))
.collect::<Vec<_>>()
.join(", ")
};
Ok(format!(
"crate::Admission::new(&[{}], &[{}])",
quoted(&admission.allowed_paths),
quoted(&admission.denied_paths)
))
}
#[cfg(test)]
mod tests {
use super::{parse_admission_expression, parse_admission_owned, render_admission};
use crate::registry_core::declaration::OwnedAdmission;
#[test]
fn admission_round_trips_through_the_constructor_form() {
assert_eq!(
parse_admission_expression("crate::Admission::new(&[\"a\", \"b\"], &[])"),
Ok("allow:a,b".to_owned())
);
assert_eq!(
parse_admission_expression("crate::Admission::new(&[], &[\"c\"])"),
Ok("deny:c".to_owned())
);
assert_eq!(
parse_admission_expression("crate::Admission::new(&[], &[])"),
Ok("ANY".to_owned())
);
assert_eq!(
parse_admission_expression("crate::Admission::allow_paths(&[\"a\"])"),
Ok("allow:a".to_owned())
);
}
#[test]
fn admission_render_and_parse_read_one_parser() {
for malformed in ["allow", "allow:", "deny:", "veto:a", "ANY:extra"] {
let rendered = render_admission(malformed).unwrap_err();
let parsed = parse_admission_owned(malformed).unwrap_err();
assert_eq!(rendered, parsed, "value `{malformed}`");
}
assert_eq!(
render_admission("allow: ui, controls ").unwrap(),
"crate::Admission::new(&[\"ui\", \"controls\"], &[])"
);
assert_eq!(
parse_admission_owned("allow: ui, controls ").unwrap(),
OwnedAdmission {
allowed_paths: vec!["ui".to_owned(), "controls".to_owned()],
denied_paths: Vec::new(),
}
);
assert_eq!(
render_admission("ALLOW : ui").unwrap(),
"crate::Admission::new(&[\"ui\"], &[])"
);
assert_eq!(
render_admission("deny:c").unwrap(),
"crate::Admission::new(&[], &[\"c\"])"
);
assert_eq!(render_admission("ANY").unwrap(), "crate::Admission::ANY");
assert_eq!(
parse_admission_owned("").unwrap(),
OwnedAdmission {
allowed_paths: Vec::new(),
denied_paths: Vec::new(),
}
);
}
#[test]
fn both_lists_survive_the_read_and_write_round_trip() {
let declaration = "crate::Admission::new(&[\"ui\"], &[\"ui/experimental\"])";
let expected = OwnedAdmission {
allowed_paths: vec!["ui".to_owned()],
denied_paths: vec!["ui/experimental".to_owned()],
};
let compact = parse_admission_expression(declaration)
.expect("the constructor form a real face carries is readable");
assert_eq!(
parse_admission_owned(&compact).expect("the compact form is readable"),
expected,
"reading `{declaration}` dropped the deny list: `{compact}`"
);
let rendered = render_admission(&compact).expect("the compact form renders");
assert!(
rendered.contains("ui/experimental"),
"the rendered declaration must still carry the deny list: {rendered}"
);
assert_eq!(
parse_admission_expression(&rendered).expect("the rendered form is readable"),
compact,
"read → render → read must be a fixed point"
);
}
#[test]
fn the_compact_form_carries_both_lists_and_refuses_duplicate_clauses() {
assert_eq!(
parse_admission_owned("allow:ui;deny:ui/experimental").unwrap(),
OwnedAdmission {
allowed_paths: vec!["ui".to_owned()],
denied_paths: vec!["ui/experimental".to_owned()],
}
);
assert_eq!(
render_admission("allow:ui;deny:ui/experimental").unwrap(),
"crate::Admission::new(&[\"ui\"], &[\"ui/experimental\"])"
);
for malformed in ["allow:a;allow:b", "allow:a;veto:b", "allow:a;deny:"] {
assert!(
parse_admission_owned(malformed).is_err(),
"parse accepted `{malformed}`"
);
assert!(
render_admission(malformed).is_err(),
"render accepted `{malformed}`"
);
}
}
}