substrate-data-derive 0.2.0

#[derive(Schema)] for substrate-data.
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

//! [`Codegen`]: what the code a derive generates depends on, passed along.

use proc_macro2::TokenStream as Tokens;
use quote::quote;

use crate::case::Case;

/// The derive running now: where `substrate_data` is, and how the
/// container names its fields or variants.
pub(crate) struct Codegen {
    /// The path of `substrate_data`: `::substrate_data`, or the container's
    /// `#[data(crate = "...")]` (a crate that re-exports it).
    pub(crate) krate: Tokens,
    /// The container's `rename_all`.
    pub(crate) case: Option<Case>,
}

impl Codegen {
    /// For a container with `path` and `case`.
    pub(crate) fn new(path: &syn::Path, case: Option<Case>) -> Codegen {
        Codegen {
            krate: quote!(#path),
            case,
        }
    }

    /// The same, fields named as in Rust: an enum's `rename_all` names its
    /// variants, not their fields.
    pub(crate) fn fields_as_written(&self) -> Codegen {
        Codegen {
            krate: self.krate.clone(),
            case: None,
        }
    }
}

/// Where `substrate_data` is for the crate deriving: its own dependency (or
/// the crate itself). A crate that has it only through a re-export says
/// where with `#[data(crate = "my_sdk::data")]`.
pub(crate) fn default_path() -> syn::Path {
    use proc_macro_crate::{FoundCrate, crate_name};
    match crate_name("substrate-data") {
        Ok(FoundCrate::Name(name)) => {
            let name = quote::format_ident!("{name}");
            syn::parse_quote!(::#name)
        }
        _ => syn::parse_quote!(::substrate_data),
    }
}