skippable-partialeq 1.0.0

PartialEq, but you can ignore fields
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Ignore fields in PartialEq custom implementations.
//!
//! # Examples
//! ```
//! use skippable_partialeq::SkippablePartialEq;
//! use chrono::{DateTime, TimeZone, Utc};
//! 

//! #[derive(Debug, SkippablePartialEq)]
//! #[exclude_suffix(at, date)]
//! pub struct Post {
//!     pub id: i64,
//!     pub content: String,
//!     pub author: i32,
//!     pub creation_date: DateTime<Utc>,
//!     pub updated_at: Option<DateTime<Utc>>,
//! }
//! 

//! assert_eq!(
//!     Post {
//!         id: 1,
//!         content: "test".to_string(),
//!         author: 1,
//!         creation_date: Utc.timestamp_millis_opt(1715017040672).unwrap(),
//!         updated_at: Some(Utc.timestamp_millis_opt(1715017020672).unwrap()),
//!     },
//!     Post {
//!         id: 1,
//!         content: "test".to_string(),
//!         author: 1,
//!         creation_date: Utc::now(),
//!         updated_at: Some(Utc::now()),
//!     }
//! ) // true
//! ```
//! 
//! You can also skip specific fields that do not follow a pattern using the `#[skip]` attribute above the fields you want to ignore:
//! 
//! ```
//! use skippable_partialeq::SkippablePartialEq;
//! use chrono::{DateTime, TimeZone, Utc};
//! 
//! #[derive(Debug, SkippablePartialEq)]
//! pub struct Post {
//!     pub id: i64,
//!     pub content: String,
//!     pub author: i32,
//!     #[skip]
//!     pub creation_date: DateTime<Utc>,
//! }

//! assert_eq!(
//!     Post {
//!         id: 1,
//!         content: "test".to_string(),
//!         author: 1,
//!         creation_date: Utc.timestamp_millis_opt(1715017040672).unwrap(),
//!     },
//!     Post {
//!         id: 1,
//!         content: "test".to_string(),
//!         author: 1,
//!         creation_date: Utc::now(),
//!     }
//! )
//! ```

extern crate proc_macro;
use proc_macro::TokenStream;
use quote::{quote, ToTokens};
use syn::{parse_macro_input, DeriveInput};


#[proc_macro_derive(SkippablePartialEq, attributes(exclude_suffix, skip))]
pub fn partial_eq_except_timestamps(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);

    let mut args: Vec<String> = Vec::new();
    for attr in ast.attrs.iter() {
        if attr.path().is_ident("exclude_suffix") {
            let meta_list = attr.meta.require_list();
            if let Ok(meta_list) = meta_list {
                for arg in meta_list.tokens.to_token_stream() {
                    let arg = arg.to_string();
                    if arg != "," {
                        args.push(arg);
                    }
                } 
            }
        }
    }

    let name = &ast.ident;
    let fields = if let syn::Data::Struct(syn::DataStruct {
        fields: syn::Fields::Named(syn::FieldsNamed { named, .. }),
        ..
    }) = ast.data
    {
        named
    } else {
        panic!("SkippablePartialEq can only be derived for structs with named fields");
    };


    if !fields.iter().any(|field| field.attrs.iter().any(|attr| attr.path().is_ident("skip"))) && args.is_empty() {
        panic!("SkippablePartialEq needs arguments to know what fields to skip");
    }
        

    let field_comparisons = fields.iter().filter_map(|field| {
        let has_specific_skip = field.attrs.iter().any(|attr| attr.path().is_ident("skip"));

        if has_specific_skip {
            return None
        } else {
            let ident = &field.ident;
            let field_type = &field.ty;
            let field_name = ident.as_ref().unwrap().to_string();
    
            if args.iter().any(|arg| field_name.ends_with(&format!("_{}", arg))) {
                if field_type
                .to_token_stream()
                .to_string()
                .starts_with("Option")
                {
                    return Some(quote! { self.#ident.is_none() && other.#ident.is_none() || self.#ident.is_some() && other.#ident.is_some()});
                }   
                    None
            } else {
                Some(quote! { &self.#ident == &other.#ident })
            }
        }
    });

    let expanded = quote! {
        impl PartialEq for #name {
            fn eq(&self, other: &Self) -> bool {
                #(#field_comparisons)&&*
            }
        }
    };

    TokenStream::from(expanded)
}