codama-attributes 0.9.1

Codama attributes definitions and parsers
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

use crate::{
    AccountDirective, ArgumentDirective, AttributeContext, DefaultValueDirective,
    DiscriminatorDirective, EncodingDirective, EnumDiscriminatorDirective, ErrorDirective,
    FieldDirective, FixedSizeDirective, NameDirective, OptionalAccountStrategyDirective,
    PdaDirective, ProgramDirective, SeedDirective, SizePrefixDirective, SkipDirective,
    TypeDirective,
};
use codama_syn_helpers::{extensions::*, Meta};
use derive_more::derive::From;

#[derive(Debug, PartialEq, From)]
pub enum CodamaDirective {
    // Type directives.
    Type(TypeDirective),
    Encoding(EncodingDirective),
    Field(FieldDirective),
    FixedSize(FixedSizeDirective),
    SizePrefix(SizePrefixDirective),

    // Default value directive.
    DefaultValue(DefaultValueDirective),

    // Multi-purpose directives.
    Discriminator(DiscriminatorDirective),
    EnumDiscriminator(EnumDiscriminatorDirective),
    Name(NameDirective),
    OptionalAccountStrategy(OptionalAccountStrategyDirective),
    Program(ProgramDirective),
    Seed(SeedDirective),
    Skip(SkipDirective),

    // Account directives.
    Pda(PdaDirective),

    // Instruction directives.
    Account(AccountDirective),
    Argument(ArgumentDirective),

    // Error directives.
    Error(ErrorDirective),
}

impl CodamaDirective {
    pub fn parse(meta: &Meta, ctx: &AttributeContext) -> syn::Result<Self> {
        let path = meta.path()?;
        match path.to_string().as_str() {
            // Type directives.
            "type" => Ok(TypeDirective::parse(meta)?.into()),
            "encoding" => Ok(EncodingDirective::parse(meta)?.into()),
            "field" => Ok(FieldDirective::parse(meta)?.into()),
            "fixed_size" => Ok(FixedSizeDirective::parse(meta)?.into()),
            "size_prefix" => Ok(SizePrefixDirective::parse(meta)?.into()),

            // Default value directive.
            "default_value" => Ok(DefaultValueDirective::parse(meta)?.into()),
            "value" => Ok(DefaultValueDirective::parse(meta)?.into()),

            // Multi-purpose directives.
            "discriminator" => Ok(DiscriminatorDirective::parse(meta)?.into()),
            "enum_discriminator" => Ok(EnumDiscriminatorDirective::parse(meta)?.into()),
            "name" => Ok(NameDirective::parse(meta)?.into()),
            "optional_account_strategy" => {
                Ok(OptionalAccountStrategyDirective::parse(meta)?.into())
            }
            "program" => Ok(ProgramDirective::parse(meta)?.into()),
            "seed" => Ok(SeedDirective::parse(meta, ctx)?.into()),
            "skip" => Ok(SkipDirective::parse(meta)?.into()),

            // Account directives.
            "pda" => Ok(PdaDirective::parse(meta)?.into()),

            // Instruction directives.
            "account" => Ok(AccountDirective::parse(meta, ctx)?.into()),
            "argument" => Ok(ArgumentDirective::parse(meta)?.into()),

            // Error directives.
            "error" => Ok(ErrorDirective::parse(meta)?.into()),

            _ => Err(path.error("unrecognized codama directive")),
        }
    }

    pub fn name(&self) -> &'static str {
        match self {
            // Type directives.
            Self::Type(_) => "type",
            Self::Encoding(_) => "encoding",
            Self::Field(_) => "field",
            Self::FixedSize(_) => "fixed_size",
            Self::SizePrefix(_) => "size_prefix",

            // Default value directive.
            Self::DefaultValue(_) => "default_value | value",

            // Multi-purpose directives.
            Self::Discriminator(_) => "discriminator",
            Self::EnumDiscriminator(_) => "enum_discriminator",
            Self::Name(_) => "name",
            Self::OptionalAccountStrategy(_) => "optional_account_strategy",
            Self::Program(_) => "program",
            Self::Seed(_) => "seed",
            Self::Skip(_) => "skip",

            // Account directives.
            Self::Pda(_) => "pda",

            // Instruction directives.
            Self::Account(_) => "account",
            Self::Argument(_) => "argument",

            // Error directives.
            Self::Error(_) => "error",
        }
    }
}