toolu-orm-macros 0.2.0

Proc macros (Table, FromRow, relations) for toolu-orm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Parsing of `#[index]` and `#[unique_index]` attributes and the [`TableInput`] type.
//!
//! # Public API
//!
//! - [`IndexInput`] — parsed index definition
//! - [`TableInput`] — aggregated table macro input
//! - [`parse_index_attrs`] — extract index attrs from a struct
//!
//! # Usage
//!
//! ```ignore
//! let indexes = parse_index_attrs(&mut item_struct)?;
//! ```

use syn::{Attribute, Ident, ItemStruct, Result};

use super::column_parsing::ColumnInput;

pub struct IndexInput {
  pub name: String,
  pub columns: Vec<String>,
  pub unique: bool,
}

pub struct TableInput {
  pub table_name: String,
  pub strict: bool,
  pub struct_name: Ident,
  pub columns: Vec<ColumnInput>,
  pub indexes: Vec<IndexInput>,
}

pub fn parse_index_attrs(item: &mut ItemStruct) -> Result<Vec<IndexInput>> {
  let mut indexes = Vec::new();
  let mut remaining_attrs = Vec::new();

  for attr in &item.attrs {
    if attr.path().is_ident("index") {
      indexes.push(parse_index_attr(attr, false)?);
    } else if attr.path().is_ident("unique_index") {
      indexes.push(parse_index_attr(attr, true)?);
    } else {
      remaining_attrs.push(attr.clone());
    }
  }
  item.attrs = remaining_attrs;
  Ok(indexes)
}

fn parse_index_attr(attr: &Attribute, unique: bool) -> Result<IndexInput> {
  let args = attr
    .parse_args_with(syn::punctuated::Punctuated::<syn::Expr, syn::Token![,]>::parse_terminated)?;
  let mut iter = args.iter();
  let name = match iter.next() {
    Some(syn::Expr::Lit(syn::ExprLit {
      lit: syn::Lit::Str(s),
      ..
    })) => s.value(),
    _ => {
      return Err(syn::Error::new_spanned(
        attr,
        "first arg must be index name string",
      ))
    },
  };
  let columns: Vec<String> = iter
    .map(|expr| {
      if let syn::Expr::Path(p) = expr {
        Ok(
          p.path
            .get_ident()
            .map(|i| i.to_string())
            .unwrap_or_default(),
        )
      } else {
        Err(syn::Error::new_spanned(expr, "expected column identifier"))
      }
    })
    .collect::<Result<_>>()?;
  Ok(IndexInput {
    name,
    columns,
    unique,
  })
}