use proc_macro::{Delimiter, TokenStream, TokenTree};
pub(crate) fn observable(input: TokenStream) -> TokenStream {
finish(expand_observable(input))
}
fn finish(result: Result<String, String>) -> TokenStream {
match result {
Ok(out) => out
.parse()
.unwrap_or_else(|e| panic!("generated code did not parse: {e}")),
Err(msg) => format!("compile_error!({msg:?});")
.parse()
.expect("compile_error! literal always parses"),
}
}
#[derive(Default)]
struct FieldDef {
name: String,
ty: String,
key: bool,
skip: bool,
}
struct StructDef {
name: String,
fields: Vec<FieldDef>,
}
fn expand_observable(input: TokenStream) -> Result<String, String> {
let def = parse_struct(input)?;
let keys: Vec<&FieldDef> = def.fields.iter().filter(|f| f.key).collect();
if keys.len() > 1 {
return Err(format!(
"Observable: `{}` marks more than one field #[obs(key)]",
def.name
));
}
Ok(emit_observable(&def))
}
fn emit_observable(def: &StructDef) -> String {
let name = &def.name;
let observed: Vec<&FieldDef> = def.fields.iter().filter(|f| !f.skip).collect();
let mut out = String::new();
if let Some(k) = def.fields.iter().find(|f| f.key) {
out.push_str(&format!(
"impl day_model::Identified for {name} {{\n\
\x20 fn key(&self) -> day_model::Key {{ day_model::AsKey::as_key(&self.{}) }}\n\
}}\n",
k.name
));
}
let trait_name = format!("{name}Fields");
out.push_str(&format!(
"#[allow(non_camel_case_types)]\npub trait {trait_name}: day_model::Source<{name}> + Sized {{\n"
));
for f in &observed {
out.push_str(&format!(
" fn {}(self) -> day_model::Field<Self, {name}, {}> {{\n\
\x20 day_model::project(self, \"{}\", |s| &s.{}, |s| &mut s.{})\n\
\x20 }}\n",
f.name, f.ty, f.name, f.name, f.name
));
}
out.push_str("}\n");
out.push_str(&format!(
"impl<S: day_model::Source<{name}>> {trait_name} for S {{}}\n"
));
out.push_str(&format!(
"impl day_model::ApplyField for {name} {{\n\
\x20 fn apply_field(&mut self, label: &str, value: &dyn ::core::any::Any) -> bool {{\n\
\x20 match label {{\n{}\
\x20 _ => false,\n\
\x20 }}\n\
\x20 }}\n\
\x20 fn read_field(&self, label: &str) -> \
Option<::std::rc::Rc<dyn ::core::any::Any>> {{\n\
\x20 match label {{\n{}\
\x20 _ => None,\n\
\x20 }}\n\
\x20 }}\n\
}}\n",
observed
.iter()
.map(|f| format!(
" \"{}\" => match value.downcast_ref::<{}>() {{\n\
\x20 Some(v) => {{\n\
\x20 self.{} = v.clone();\n\
\x20 true\n\
\x20 }}\n\
\x20 None => false,\n\
\x20 }},\n",
f.name, f.ty, f.name
))
.collect::<String>(),
observed
.iter()
.map(|f| format!(
" \"{}\" => Some(::std::rc::Rc::new(self.{}.clone())),\n",
f.name, f.name
))
.collect::<String>()
));
out.push_str(&format!(
"impl {name} {{\n pub const OBSERVED_FIELDS: &'static [&'static str] = &[{}];\n}}\n",
observed
.iter()
.map(|f| format!("\"{}\"", f.name))
.collect::<Vec<_>>()
.join(", ")
));
out
}
fn parse_struct(input: TokenStream) -> Result<StructDef, String> {
let tokens: Vec<TokenTree> = input.into_iter().collect();
let mut i = 0;
while i < tokens.len() {
match &tokens[i] {
TokenTree::Ident(id) if id.to_string() == "struct" => break,
_ => i += 1,
}
}
if i >= tokens.len() {
return Err("the derive expects a struct".into());
}
let name = match tokens.get(i + 1) {
Some(TokenTree::Ident(id)) => id.to_string(),
_ => return Err("the derive expects a named struct".into()),
};
let body = match tokens.get(i + 2) {
Some(TokenTree::Group(g)) if g.delimiter() == Delimiter::Brace => g.stream(),
Some(TokenTree::Punct(p)) if p.as_char() == '<' => {
return Err("the derive does not support generic structs yet".into());
}
_ => return Err("the derive expects a struct with named fields".into()),
};
Ok(StructDef {
name,
fields: parse_fields(body)?,
})
}
fn attr_items(bracket: &proc_macro::Group, name: &str) -> Option<Vec<Vec<TokenTree>>> {
let inner: Vec<TokenTree> = bracket.stream().into_iter().collect();
match (inner.first(), inner.get(1)) {
(Some(TokenTree::Ident(id)), Some(TokenTree::Group(g)))
if id.to_string() == name && g.delimiter() == Delimiter::Parenthesis =>
{
let mut items = vec![Vec::new()];
for tt in g.stream() {
match &tt {
TokenTree::Punct(p) if p.as_char() == ',' => items.push(Vec::new()),
_ => items.last_mut().expect("never empty").push(tt),
}
}
items.retain(|item| !item.is_empty());
Some(items)
}
_ => None,
}
}
fn tokens_text(tokens: &[TokenTree]) -> String {
tokens.iter().cloned().collect::<TokenStream>().to_string()
}
fn parse_fields(body: TokenStream) -> Result<Vec<FieldDef>, String> {
let mut fields = Vec::new();
let mut chunk: Vec<TokenTree> = Vec::new();
let mut angle_depth = 0i32;
let mut prev_dash = false;
for tt in body {
match &tt {
TokenTree::Punct(p) if p.as_char() == '<' => {
angle_depth += 1;
chunk.push(tt);
}
TokenTree::Punct(p) if p.as_char() == '>' && !prev_dash => {
angle_depth = (angle_depth - 1).max(0);
chunk.push(tt);
}
TokenTree::Punct(p) if p.as_char() == ',' && angle_depth == 0 => {
if !chunk.is_empty() {
fields.push(parse_one(&chunk)?);
chunk.clear();
}
}
_ => chunk.push(tt),
}
prev_dash = matches!(
chunk.last(),
Some(TokenTree::Punct(p)) if p.as_char() == '-'
);
}
if !chunk.is_empty() {
fields.push(parse_one(&chunk)?);
}
Ok(fields)
}
fn parse_one(chunk: &[TokenTree]) -> Result<FieldDef, String> {
let mut i = 0;
let mut f = FieldDef::default();
while i < chunk.len() {
match &chunk[i] {
TokenTree::Punct(p) if p.as_char() == '#' => {
if let Some(TokenTree::Group(g)) = chunk.get(i + 1) {
if let Some(items) = attr_items(g, "obs") {
for item in items {
match item.as_slice() {
[TokenTree::Ident(id)] if id.to_string() == "key" => f.key = true,
[TokenTree::Ident(id)] if id.to_string() == "skip" => {
f.skip = true;
}
other => {
return Err(format!(
"unknown #[obs] option: `{}` (supported: key, skip)",
tokens_text(other)
));
}
}
}
} else if let Some(items) = attr_items(g, "model") {
f.key |= items.iter().any(|item| {
matches!(item.as_slice(), [TokenTree::Ident(id)] if id.to_string() == "id")
});
}
i += 2;
continue;
}
return Err("malformed attribute on a field".into());
}
_ => break,
}
}
if let Some(TokenTree::Ident(id)) = chunk.get(i)
&& id.to_string() == "pub"
{
i += 1;
if let Some(TokenTree::Group(g)) = chunk.get(i)
&& g.delimiter() == Delimiter::Parenthesis
{
i += 1;
}
}
f.name = match chunk.get(i) {
Some(TokenTree::Ident(id)) => id.to_string(),
_ => return Err("expected a field name".into()),
};
i += 1;
match chunk.get(i) {
Some(TokenTree::Punct(p)) if p.as_char() == ':' => i += 1,
_ => return Err(format!("expected `:` after field `{}`", f.name)),
}
f.ty = tokens_text(&chunk[i..]);
if f.ty.is_empty() {
return Err(format!("field `{}` has no type", f.name));
}
Ok(f)
}