orma-derive 0.3.3

Derive macros for Orma
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

#![doc(
    html_logo_url = "https://raw.githubusercontent.com/RedSoftwareSystems/rust-orma/master/orma.svg?sanitize=true"
)]
//! This crate provides derive macros for orma.
//!
//! ## Example
//!
//! ```edition2018
//!  use orma::*;
//!  use serde::{Serialize, Deserialize};
//!
//!  #[orma_derive::orma_obj(table = "table_name")]
//!  #[derive(Serialize, Deserialize)]
//!  struct TestData {
//!      field_1: String,
//!      field_2: String,
//!      some_other_filed: String,
//!  }
//!
//! ```
//!
extern crate proc_macro;

mod dbdata;
mod test_impl;

use syn::{parse_macro_input, AttributeArgs, DeriveInput};

/// This crate provides derive macros for orma.
///
/// ## Example
///
/// ```edition2018
///  use serde::{Serialize, Deserialize};
///
///  #[orma_derive::orma_obj(table = "table_name")]
///  #[derive(Serialize, Deserialize)]
///  struct TestData {
///      field_1: String,
///      field_2: String,
///      some_other_filed: String,
///  }
///
/// ```
///
#[proc_macro_attribute]
pub fn orma_obj(
    args: proc_macro::TokenStream,
    input: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    // Parse tokens
    let args = parse_macro_input!(args as AttributeArgs);
    let mut input: DeriveInput = parse_macro_input!(input);
    let gen = dbdata::impl_orma(&args, &mut input);

    // println!(
    //     r#"
    // --------------------- RESULT CODE ---------------------
    // {}
    // -------------------------------------------------------"#,
    //     gen
    // );
    // Return the generated impl
    gen.into()
}

/// This macro produces an async test.
///
/// For each argument there is a function with the same name that provides the value for that argument and receives as input
/// the name of the test function (as &str)
///
/// # Example:
/// ```edition2018
/// fn connection(input: &str) -> &str {
///     input
/// }
///
/// #[orma_derive::test]
/// async fn test_orma_test(connection: &str) {
///     assert_eq!(data, "test_orma_test");
/// }
/// ```
#[proc_macro_attribute]
pub fn test(
    _args: proc_macro::TokenStream,
    body: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    // Parse tokens
    let ast = syn::parse(body).unwrap();

    // Build impl
    let gen = test_impl::test_impl(ast);

    // println!(
    //     r#"
    // --------------------- RESULT CODE ---------------------
    // {}
    // -------------------------------------------------------"#,
    //     gen
    // );
    // Return the generated impl

    gen.into()
}