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

use codama_nodes::{BytesEncoding, Docs, InstructionOptionalAccountStrategy, IsAccountSigner};
use codama_syn_helpers::{extensions::*, Meta};
use syn::Expr;

pub trait FromMeta
where
    Self: Sized,
{
    fn from_meta(meta: &Meta) -> syn::Result<Self>;
}

impl FromMeta for bool {
    fn from_meta(meta: &Meta) -> syn::Result<Self> {
        match meta {
            // This is to allow attributes like `#[account(signer)]`
            // where `signer` is interpreted as `signer = true`.
            Meta::Expr(Expr::Path(_)) => Ok(true),
            _ => meta.as_expr_or_value_expr()?.as_bool(),
        }
    }
}

impl FromMeta for IsAccountSigner {
    fn from_meta(meta: &Meta) -> syn::Result<Self> {
        if let Ok(value) = bool::from_meta(meta) {
            return Ok(value.into());
        }
        let expr = meta.as_expr_or_value_expr()?;
        match expr.as_string() {
            Ok(value) if value == "either" => Ok(Self::Either),
            _ => Err(expr.error("expected boolean or `\"either\"`")),
        }
    }
}

impl FromMeta for BytesEncoding {
    fn from_meta(meta: &Meta) -> syn::Result<Self> {
        let expr = meta.as_expr_or_value_expr()?;
        if let Ok(value) = expr.as_string() {
            if let Ok(encoding) = Self::try_from(value) {
                return Ok(encoding);
            }
        }
        Err(expr.error("expected one of: \"base16\", \"base58\", \"base64\", \"utf8\""))
    }
}

impl FromMeta for InstructionOptionalAccountStrategy {
    fn from_meta(meta: &Meta) -> syn::Result<Self> {
        let expr = meta.as_expr_or_value_expr()?;
        let path = expr.as_path()?;
        match path.to_string().as_str() {
            "omitted" => Ok(Self::Omitted),
            "program_id" => Ok(Self::ProgramId),
            _ => Err(path.error("expected `omitted` or `program_id`")),
        }
    }
}

impl FromMeta for Docs {
    fn from_meta(meta: &Meta) -> syn::Result<Self> {
        match meta {
            Meta::PathList(pl) if pl.eq_token.is_some() => {
                let strings: Vec<String> = pl
                    .as_meta_list()
                    .parse_comma_args::<syn::LitStr>()?
                    .into_iter()
                    .map(|lit| lit.value())
                    .collect();
                Ok(strings.into())
            }
            Meta::PathValue(pv) => pv.value.as_expr()?.as_string().map(|s| vec![s].into()),
            _ => Err(meta.error("expected a string or array of strings")),
        }
    }
}