WIP

Author: technetos

examples/hello_database/src/main.rs

@@ -1,3 +1,5 @@
+#![feature(custom_attribute)]
+
 #[macro_use]
 extern crate diesel as other_diesel;
 
@@ -13,8 +15,7 @@ use uuid::Uuid;
 use crate::schema::worlds;
 mod schema;
 
-
-#[resource(schema = worlds, table = "worlds")]
+#[resource]
 struct World {
     uuid: Uuid,
     name: String,

postgres_resource_derive/Cargo.toml

@@ -5,7 +5,7 @@ authors = ["technetos <[email protected]>"]
 edition = "2018"
 
 [dependencies]
-syn = { version = "0.15.13", features = ["extra-traits", "full"]}
+syn = { version = "0.15.23", features = ["extra-traits", "full"]}
 quote = "0.6.8"
 proc-macro2 = "0.4.20"
 

postgres_resource_derive/src/attr.rs

@@ -0,0 +1,54 @@
+use proc_macro2::{Span, TokenTree::Literal};
+use syn::{
+    parse::{Parse, ParseStream, Result},
+    punctuated::Punctuated,
+    token, Attribute, Ident, LitStr,
+    Meta::*,
+    MetaNameValue,
+    Error,
+    Lit,
+};
+
+#[derive(Debug)]
+pub struct Attrs {
+    db_conn: Option<LitStr>,
+    table: Option<LitStr>,
+}
+
+impl Parse for Attrs {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+
+        let mut db_conn: Option<LitStr> = None;
+        let mut table: Option<LitStr> = None;
+
+        for attr in &attrs {
+            if attr.path.is_ident("table") {
+                table = Self::parse_attr(attr, "table")?;
+            }
+            if attr.path.is_ident("env_var") {
+                db_conn = Self::parse_attr(attr, "env_var")?;
+            }
+        }
+
+        println!("{:#?}", table);
+
+        Ok(Attrs { db_conn, table })
+    }
+}
+
+impl Attrs {
+    fn parse_attr(attr: &Attribute, expected: &str) -> Result<Option<LitStr>> {
+        match attr.parse_meta()? {
+            NameValue(MetaNameValue { lit: Lit::Str(lit_str), .. }) => {
+                lit_str.parse().map(Some)
+            }
+            _ => {
+                let error_span = attr.bracket_token.span;
+                let message = &format!("expected #[{} = \"...\"]", expected);
+                Err(syn::Error::new(error_span, message))
+            }
+        }
+    }
+}
+

postgres_resource_derive/src/builder.rs

@@ -0,0 +1,114 @@
+use crate::{attr::*, IdentExt, camel_to_snake, r#struct::*};
+
+use proc_macro2::Span;
+use syn::{
+    parse::{Parse, ParseStream, Result},
+    punctuated::Punctuated,
+    token, Attribute, Ident, LitStr,
+    Meta::*,
+    MetaNameValue,
+};
+
+pub struct Input {
+    pub parsed_struct: Struct,
+}
+
+pub trait Builder<'i> {
+    fn build(self, input: &'i Input) -> Result<proc_macro2::TokenStream>;
+}
+
+pub struct InferredTableMacro;
+
+impl<'i> Builder<'i> for InferredTableMacro {
+    fn build(self, input: &'i Input) -> Result<proc_macro2::TokenStream> {
+        let model_name = camel_to_snake(&input.parsed_struct.ident.to_string()[..]) + "s";
+        let literal = LitStr::new(&model_name, Span::call_site());
+        Ok(quote!(#[table_name = #literal]))
+    }
+}
+
+pub struct CustomTableMacro<B>(pub B);
+
+impl<'i, B: Builder<'i>> Builder<'i> for CustomTableMacro<B> {
+    fn build(self, input: &'i Input) -> Result<proc_macro2::TokenStream> {
+        self.0.build(input)
+    }
+}
+
+pub struct ModelWithId<B>(pub B);
+
+impl<'i, B: Builder<'i>> Builder<'i> for ModelWithId<B> {
+    fn build(self, input: &'i Input) -> Result<proc_macro2::TokenStream> {
+        let model_name_with_id = input.parsed_struct.ident.append("WithId");
+        let fields = self.0.build(input)?;
+
+        Ok(quote! {
+            pub struct #model_name_with_id {
+                #fields
+            }
+        })
+    }
+}
+
+pub struct Fields;
+
+impl<'i> Builder<'i> for Fields {
+    fn build(self, input: &'i Input) -> Result<proc_macro2::TokenStream> {
+        let mut fields = Vec::new();
+        fields.push(quote!(pub id: i32));
+
+        let model_name = &input.parsed_struct.ident;
+        fields.push(quote!(pub inner: #model_name));
+
+        input.parsed_struct.fields.iter().for_each(|field| {
+            if field.fk() {
+                let ty = field.ty();
+                let name = &field.name;
+                fields.push(quote!(pub #name: #ty));
+            }
+        });
+
+        Ok(quote!(#(#fields,)*))
+    }
+}
+
+pub struct Model<B>(pub B);
+
+impl<'i, B: Builder<'i>> Builder<'i> for Model<B> {
+    fn build(self, input: &'i Input) -> Result<proc_macro2::TokenStream> {
+        let model_name = &input.parsed_struct.ident;
+        let fields = self.0.build(input)?;
+
+        Ok(quote! {
+            pub struct #model_name {
+                #fields
+            }
+        })
+    }
+}
+
+pub struct InnerFields;
+
+impl<'i> Builder<'i> for InnerFields {
+    fn build(self, input: &'i Input) -> Result<proc_macro2::TokenStream> {
+        let mut fields = Vec::new();
+        input.parsed_struct.fields.iter().for_each(|field| {
+            if !field.fk() {
+                let ty = field.ty();
+                let name = &field.name;
+                fields.push(quote!(pub #name: #ty));
+            }
+        });
+
+        Ok(quote!(#(#fields,)*))
+    }
+}
+
+pub struct Table;
+
+impl<'i> Builder<'i> for Table {
+    fn build(self, input: &'i Input) -> Result<proc_macro2::TokenStream> {
+        let model = camel_to_snake(&input.parsed_struct.ident.to_string()[..]) + "s";
+        quote!(crate::schema::#model)
+    }
+}

postgres_resource_derive/src/field.rs

@@ -0,0 +1,62 @@
+use syn::{
+    parse::{Parse, ParseStream, Result},
+    punctuated::Punctuated,
+    token, Attribute, Ident,
+};
+
+#[derive(Debug, PartialEq)]
+enum FieldAttr {
+    Optional,
+    ForeignKey,
+}
+
+#[derive(Debug)]
+pub struct Field {
+    attr: Vec<FieldAttr>,
+    pub name: Ident,
+    ty: Ident,
+}
+
+impl Parse for Field {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let attr = Self::parse_attr(&input)?;
+        let name: Ident = input.parse()?;
+        let _: Token![:] = input.parse()?;
+        let ty = input.parse()?;
+
+        Ok(Field { attr, name, ty })
+    }
+}
+
+impl Field {
+    fn parse_attr(input: &ParseStream) -> Result<Vec<FieldAttr>> {
+        let mut result = Vec::new();
+        if let Some(attrs) = input.call(Attribute::parse_outer).ok() {
+            attrs.iter().for_each(|attr| {
+                let ident = &attr.path.segments[0].ident;
+
+                match &ident.to_string()[..] {
+                    "optional" => result.push(FieldAttr::Optional),
+                    "fk" => result.push(FieldAttr::ForeignKey),
+                    _ => panic!("Invalid attribute for field"),
+                }
+            });
+        }
+        Ok(result)
+    }
+
+    pub fn ty(&self) -> proc_macro2::TokenStream {
+        let ty = &self.ty;
+        let mut ty_tokens = quote!(#ty);
+
+        if self.attr.contains(&FieldAttr::Optional) {
+            ty_tokens = quote!(Option<#ty>);
+        }
+
+        ty_tokens
+    }
+
+    pub fn fk(&self) -> bool {
+        self.attr.contains(&FieldAttr::ForeignKey)
+    }
+}