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()
}