scrypto-derive 1.3.1

A collection of macros for writing Scrypto blueprints, from the Radix DLT project.
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

use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::token::{As, Brace, Paren};
use syn::{
    braced, parenthesized, Attribute, Ident, ItemConst, ItemImpl, ItemMacro, ItemStruct, ItemUse,
    Path, Result, Token, Visibility,
};

/// Represents a blueprint which is a module with an optional set of attributes
pub struct Blueprint {
    pub attributes: Vec<Attribute>,
    pub module: BlueprintMod,
}

impl Parse for Blueprint {
    fn parse(input: ParseStream) -> Result<Self> {
        Ok(Self {
            attributes: input.call(Attribute::parse_outer)?,
            module: input.parse()?,
        })
    }
}

/// Represents a Blueprint module which consists of a struct and an implementation of said struct
#[allow(dead_code)] // Fields for tokens from parse for completeness
pub struct BlueprintMod {
    pub vis: Visibility,
    pub mod_token: Token![mod],
    pub module_ident: Ident,
    pub brace: Brace,
    pub use_statements: Vec<ItemUse>,
    pub const_statements: Vec<ItemConst>,
    pub macro_statements: Vec<ItemMacro>,
    pub structure: ItemStruct,
    pub implementation: ItemImpl,
    pub semi: Option<Token![;]>,
}

impl Parse for BlueprintMod {
    fn parse(input: ParseStream) -> Result<Self> {
        let content;

        let vis = input.parse()?;
        let mod_token = input.parse()?;
        let module_ident = input.parse()?;
        let brace = braced!(content in input);
        let use_statements = {
            let mut use_statements = Vec::new();
            while content.peek(Token![use]) {
                use_statements.push(content.call(ItemUse::parse)?)
            }
            use_statements
        };
        let (const_statements, macro_statements) = {
            let mut const_statements = Vec::new();
            let mut macro_statements = Vec::new();
            loop {
                let is_const = content.peek(Token![const]);
                let is_macro = content.peek2(Token![!]);
                if !is_const && !is_macro {
                    break;
                }
                if is_const {
                    const_statements.push(content.call(ItemConst::parse)?)
                }
                if is_macro {
                    macro_statements.push(content.call(ItemMacro::parse)?)
                }
            }

            (const_statements, macro_statements)
        };

        let structure = content.parse()?;
        let implementation = content.parse()?;
        let semi = input.parse()?;

        Ok(Self {
            vis,
            mod_token,
            module_ident,
            brace,
            use_statements,
            const_statements,
            macro_statements,
            structure,
            implementation,
            semi,
        })
    }
}

#[allow(dead_code)] // Fields for tokens from parse for completeness
pub struct EventsInner {
    pub paren_token: Paren,
    pub paths: Punctuated<Path, Token![,]>,
}

impl Parse for EventsInner {
    fn parse(input: ParseStream) -> Result<Self> {
        let content;
        Ok(Self {
            paren_token: parenthesized!(content in input),
            paths: content.parse_terminated(Path::parse)?,
        })
    }
}

#[allow(dead_code)] // Fields for tokens from parse for completeness
pub struct TypesInner {
    pub paren_token: Paren,
    pub aliasable_types: Punctuated<AliasableType, Token![,]>,
}

impl Parse for TypesInner {
    fn parse(input: ParseStream) -> Result<Self> {
        let content;
        Ok(Self {
            paren_token: parenthesized!(content in input),
            aliasable_types: content.parse_terminated(AliasableType::parse)?,
        })
    }
}

pub struct AliasableType {
    pub path: Path,
    pub alias: Option<Ident>,
}

impl Parse for AliasableType {
    fn parse(input: ParseStream) -> Result<Self> {
        let rust_type: Path = input.parse()?;
        let alias = if input.parse::<Option<As>>()?.is_some() {
            Some(input.parse::<Ident>()?)
        } else {
            None
        };

        Ok(Self {
            path: rust_type,
            alias,
        })
    }
}