diesel_derives/
util.rs

Help
1use proc_macro2::TokenStream;
2use quote::quote;
3use syn::parse::{Parse, ParseStream, Peek, Result};
4use syn::token::Eq;
5use syn::{parenthesized, parse_quote, Data, DeriveInput, GenericArgument, Ident, Type};
6
7use crate::model::Model;
8
9pub const COLUMN_NAME_NOTE: &str = "column_name = foo";
10pub const SQL_TYPE_NOTE: &str = "sql_type = Foo";
11pub const SERIALIZE_AS_NOTE: &str = "serialize_as = Foo";
12pub const DESERIALIZE_AS_NOTE: &str = "deserialize_as = Foo";
13pub const TABLE_NAME_NOTE: &str = "table_name = foo";
14pub const TREAT_NONE_AS_DEFAULT_VALUE_NOTE: &str = "treat_none_as_default_value = true";
15pub const TREAT_NONE_AS_NULL_NOTE: &str = "treat_none_as_null = true";
16pub const BELONGS_TO_NOTE: &str = "belongs_to(Foo, foreign_key = foo_id)";
17pub const MYSQL_TYPE_NOTE: &str = "mysql_type(name = \"foo\")";
18pub const SQLITE_TYPE_NOTE: &str = "sqlite_type(name = \"foo\")";
19pub const POSTGRES_TYPE_NOTE: &str = "postgres_type(name = \"foo\", schema = \"public\")";
20pub const POSTGRES_TYPE_NOTE_ID: &str = "postgres_type(oid = 37, array_oid = 54)";
21pub const SELECT_EXPRESSION_NOTE: &str =
22    "select_expression = schema::table_name::column_name.is_not_null()";
23pub const SELECT_EXPRESSION_TYPE_NOTE: &str =
24    "select_expression_type = dsl::IsNotNull<schema::table_name::column_name>";
25pub const CHECK_FOR_BACKEND_NOTE: &str = "diesel::pg::Pg";
26
27pub fn unknown_attribute(name: &Ident, valid: &[&str]) -> syn::Error {
28    let prefix = if valid.len() == 1 { "" } else { " one of" };
29
30    syn::Error::new(
31        name.span(),
32        format!(
33            "unknown attribute, expected{prefix} `{}`",
34            valid.join("`, `")
35        ),
36    )
37}
38
39pub fn parse_eq<T: Parse>(input: ParseStream, help: &str) -> Result<T> {
40    if input.is_empty() {
41        return Err(syn::Error::new(
42            input.span(),
43            format!(
44                "unexpected end of input, expected `=`\n\
45                 help: The correct format looks like `#[diesel({help})]`",
46            ),
47        ));
48    }
49
50    input.parse::<Eq>()?;
51    input.parse()
52}
53
54pub fn parse_paren<T: Parse>(input: ParseStream, help: &str) -> Result<T> {
55    if input.is_empty() {
56        return Err(syn::Error::new(
57            input.span(),
58            format!(
59                "unexpected end of input, expected parentheses\n\
60                 help: The correct format looks like `#[diesel({help})]`",
61            ),
62        ));
63    }
64
65    let content;
66    parenthesized!(content in input);
67    content.parse()
68}
69
70pub fn parse_paren_list<T, D>(
71    input: ParseStream,
72    help: &str,
73    sep: D,
74) -> Result<syn::punctuated::Punctuated<T, <D as Peek>::Token>>
75where
76    T: Parse,
77    D: Peek,
78    D::Token: Parse,
79{
80    if input.is_empty() {
81        return Err(syn::Error::new(
82            input.span(),
83            format!(
84                "unexpected end of input, expected parentheses\n\
85                 help: The correct format looks like `#[diesel({help})]`",
86            ),
87        ));
88    }
89
90    let content;
91    parenthesized!(content in input);
92    content.parse_terminated(T::parse, sep)
93}
94
95pub fn wrap_in_dummy_mod(item: TokenStream) -> TokenStream {
96    quote! {
97        #[allow(unused_imports)]
98        const _: () = {
99            // This import is not actually redundant. When using diesel_derives
100            // inside of diesel, `diesel` doesn't exist as an extern crate, and
101            // to work around that it contains a private
102            // `mod diesel { pub use super::*; }` that this import will then
103            // refer to. In all other cases, this imports refers to the extern
104            // crate diesel.
105            use diesel;
106
107            #item
108        };
109    }
110}
111
112pub fn inner_of_option_ty(ty: &Type) -> &Type {
113    option_ty_arg(ty).unwrap_or(ty)
114}
115
116pub fn is_option_ty(ty: &Type) -> bool {
117    option_ty_arg(ty).is_some()
118}
119
120fn option_ty_arg(mut ty: &Type) -> Option<&Type> {
121    use syn::PathArguments::AngleBracketed;
122
123    // Check the inner equivalent type
124    loop {
125        match ty {
126            Type::Group(group) => ty = &group.elem,
127            Type::Paren(paren) => ty = &paren.elem,
128            _ => break,
129        }
130    }
131
132    match *ty {
133        Type::Path(ref ty) => {
134            let last_segment = ty.path.segments.iter().last().unwrap();
135            match last_segment.arguments {
136                AngleBracketed(ref args) if last_segment.ident == "Option" => {
137                    match args.args.iter().last() {
138                        Some(GenericArgument::Type(ty)) => Some(ty),
139                        _ => None,
140                    }
141                }
142                _ => None,
143            }
144        }
145        _ => None,
146    }
147}
148
149pub fn ty_for_foreign_derive(item: &DeriveInput, model: &Model) -> Result<Type> {
150    if model.foreign_derive {
151        match item.data {
152            Data::Struct(ref body) => match body.fields.iter().next() {
153                Some(field) => Ok(field.ty.clone()),
154                None => Err(syn::Error::new(
155                    proc_macro2::Span::call_site(),
156                    "foreign_derive requires at least one field",
157                )),
158            },
159            _ => Err(syn::Error::new(
160                proc_macro2::Span::call_site(),
161                "foreign_derive can only be used with structs",
162            )),
163        }
164    } else {
165        let ident = &item.ident;
166        let (_, ty_generics, ..) = item.generics.split_for_impl();
167        Ok(parse_quote!(#ident #ty_generics))
168    }
169}
170
171pub fn camel_to_snake(name: &str) -> String {
172    let mut result = String::with_capacity(name.len());
173    result.push_str(&name[..1].to_lowercase());
174    for character in name[1..].chars() {
175        if character.is_uppercase() {
176            result.push('_');
177            for lowercase in character.to_lowercase() {
178                result.push(lowercase);
179            }
180        } else {
181            result.push(character);
182        }
183    }
184    result
185}
diesel_derives/util.rs

diesel_derives/
util.rs
