first failed attempt to implement #[influx_aware()]

Author: dungex

influxdb/tests/derive_integration_tests.rs

@@ -17,8 +17,9 @@ use utilities::{assert_result_ok, create_client, create_db, delete_db, run_test}
 #[cfg_attr(feature = "use-serde", derive(Deserialize))]
 struct WeatherReading {
     time: DateTime<Utc>,
+    #[influx_aware(ignore)]
     humidity: i32,
-    #[tag]
+    #[influx_aware(tag)]
     wind_strength: Option<u64>,
 }
 

influxdb_derive/src/lib.rs

@@ -9,7 +9,7 @@ fn krate() -> TokenStream2 {
     quote!(::influxdb)
 }
 
-#[proc_macro_derive(InfluxDbWriteable, attributes(tag))]
+#[proc_macro_derive(InfluxDbWriteable, attributes(tag, influx_aware))]
 pub fn derive_writeable(tokens: TokenStream) -> TokenStream {
     expand_writeable(tokens)
 }

influxdb_derive/src/writeable.rs

@@ -1,33 +1,82 @@
 use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
+use proc_macro2::{TokenStream as TokenStream2, TokenTree as TokenTree2};
 use quote::{format_ident, quote};
 use syn::{parse_macro_input, Field, Fields, Ident, ItemStruct};
 
+#[derive(Debug)]
 struct WriteableField {
     ident: Ident,
     is_tag: bool,
+    is_ignore: bool,
 }
 
 impl From<Field> for WriteableField {
     fn from(field: Field) -> WriteableField {
         let ident = field.ident.expect("fields without ident are not supported");
-        let is_tag = field.attrs.iter().any(|attr| {
+
+        let check_influx_aware = |attr: &syn::Attribute| -> bool {
             attr.path
                 .segments
                 .iter()
                 .last()
                 .map(|seg| seg.ident.to_string())
                 .unwrap_or_default()
-                == "tag"
+                == "influx_aware"
+        };
+
+        let check_for_attr = |token_tree, ident_cmp: &str| -> bool {
+            match token_tree {
+                TokenTree2::Group(group) => group
+                    .stream()
+                    .into_iter()
+                    .next()
+                    .map(|token_tree| match token_tree {
+                        TokenTree2::Ident(ident) => ident.to_string() == ident_cmp.to_string(),
+                        _ => false,
+                    })
+                    .unwrap(),
+                _ => false,
+            }
+        };
+
+        let is_ignore = field.attrs.iter().any(|attr| {
+            if !check_influx_aware(attr) {
+                return false;
+            }
+
+            attr.tokens
+                .clone()
+                .into_iter()
+                .next()
+                .map(|token_tree| check_for_attr(token_tree, "ignore"))
+                .unwrap()
         });
-        WriteableField { ident, is_tag }
+
+        let is_tag = field.attrs.iter().any(|attr| {
+            if !check_influx_aware(attr) {
+                return false;
+            }
+            attr.tokens
+                .clone()
+                .into_iter()
+                .next()
+                .map(|token_tree| check_for_attr(token_tree, "tag"))
+                .unwrap()
+        });
+
+        WriteableField {
+            ident,
+            is_tag,
+            is_ignore,
+        }
     }
 }
 
 pub fn expand_writeable(tokens: TokenStream) -> TokenStream {
     let krate = super::krate();
 
-    let input = parse_macro_input!(tokens as ItemStruct);
+    let tokens_cloned = tokens.clone();
+    let input = parse_macro_input!(tokens_cloned as ItemStruct);
     let ident = input.ident;
     let generics = input.generics;
 
@@ -38,6 +87,7 @@ pub fn expand_writeable(tokens: TokenStream) -> TokenStream {
             .named
             .into_iter()
             .map(WriteableField::from)
+            .filter(|field| !field.is_ignore)
             .filter(|field| field.ident.to_string() != time_field.to_string())
             .map(|field| {
                 let ident = field.ident;