tslink 0.4.2

Creates typescript definitions based on rust code
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

use crate::{
    config::cfg::EnumRepresentation, context::Context, error::E, nature::{Nature, TypeAsString, TypeTokenStream, VariableTokenStream}
};
use proc_macro2::TokenStream;
use quote::{quote, format_ident};

#[derive(Clone, Debug)]
pub enum Referred {
    // Name, Context, Field
    TupleStruct(String, Context, Option<Box<Nature>>),
    // Name, Context, Fields
    Struct(String, Context, Vec<Nature>),
    // Name, Context, Variants, EnumRepresentation
    Enum(String, Context, Vec<Nature>, EnumRepresentation),
    // name, context, values, is_flat
    EnumVariant(String, Context, Vec<Nature>, bool, EnumRepresentation),
    // Name, Context, FuncNature
    Func(String, Context, Box<Nature>),
    // Name, Context, Nature, Binding
    Field(String, Context, Box<Nature>, Option<String>),
    // Name, Context, Nature, Binding
    FuncArg(String, Context, Box<Nature>, Option<String>),
    // Name
    Ref(String, Option<Context>),
    // Alias, Nature
    Generic(String, Box<Nature>),
    // Name, Context, Type, Value
    Constant(String, Context, Box<Nature>, String)
}

impl Referred {
    pub fn is_flat_varians(variants: &[Nature]) -> Result<bool, E> {
        for variant in variants {
            if let Nature::Referred(Referred::EnumVariant(_, _, values, ..)) = variant {
                if !values.is_empty() {
                    return Ok(false);
                }
            } else {
                return Err(E::Parsing(String::from("Given Nature isn't enum varian")));
            }
        }
        Ok(true)
    }

    pub fn is_enum_flat(&self) -> Result<bool, E> {
        if let Referred::Enum(_, _, variants,_) = self {
            Referred::is_flat_varians(variants)
        } else {
            Err(E::Parsing(String::from("Given Nature isn't enum")))
        }
    }
}

impl TypeTokenStream for Referred {
    fn type_token_stream(&self) -> Result<TokenStream, E> {
        let ident = match self {
            Self::TupleStruct(name, ..) => Ok(format_ident!("{}", name)),
            Self::Struct(name, ..) => Ok(format_ident!("{}", name)),
            Self::Enum(name, ..) => Ok(format_ident!("{}", name)),
            Self::Ref(name, ..) => Ok(format_ident!("{}", name)),
            Self::Constant(name, ..) => Ok(format_ident!("{}", name)),
            Self::EnumVariant(..) |
            Self::Func(..) |
            Self::Field(..) |
            Self::FuncArg(..) |
            Self::Generic(..) => Err(E::Other("EnumVariant, Func, Field, FuncArg, Generic of Referred doesn't support TypeTokenStream".to_string()))
        }?;
        Ok(quote! { #ident })
    }
}

impl TypeAsString for Referred {
    fn type_as_string(&self) -> Result<String, E> {
        match self {
            Self::TupleStruct(name, ..) => Ok(name.clone()),
            Self::Struct(name, ..) => Ok(name.clone()),
            Self::Enum(name, ..) => Ok(name.clone()),
            Self::Ref(name, ..) => Ok(name.clone()),
            Self::Constant(name, ..) => Ok(name.clone()),
            Self::EnumVariant(..) |
            Self::Func(..) |
            Self::Field(..) |
            Self::FuncArg(..) |
            Self::Generic(..) => Err(E::Other("EnumVariant, Func, Field, FuncArg, Generic of Referred doesn't support TypeAsString".to_string()))
        }
    }
}

impl VariableTokenStream for Referred {
    fn variable_token_stream(&self, var_name: &str, err: Option<&Nature>) -> Result<TokenStream, E> {
        let var_name = format_ident!("{}", var_name);
        match self {   
            Self::Ref(_, _) => {
                Ok(if let Some(nature) = err {
                    let err_type_ref = nature.type_token_stream()?;
                    quote! {
                        serde_json::to_string(&#var_name).map_err(|e| Into::<#err_type_ref>::into(e))?
                    }
                } else {
                    quote! {
                        serde_json::to_string(&#var_name).expect("Converting to JSON string")
                    }
                })
            },
            _ => {
                Err(E::Parsing(format!("Only reference to entity (struct / enum) can be convert into JSON string (var: {var_name})")))
            }
        }
    }
}