ast_openapi 0.1.0

Generate OpenAPI without any boilerplate
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

use syn::{visit::Visit, Expr, File, Item, ItemFn, PatIdent, Stmt};

fn main() {
    todo!()
}

pub fn find_main(ast: File) {
    let functions = ast
        .items
        .iter()
        .filter_map(|item| {
            if let Item::Fn(item_fn) = item {
                Some(item_fn.clone())
            } else {
                None
            }
        })
        .collect::<Vec<ItemFn>>();

    for func in functions {
        if &func.sig.ident == "main" {
            for statement in &func.block.stmts {
                if let Stmt::Local(local) = statement {
                    if let Some(pattern_ident) = get_pattern_ident(&local.pat) {
                        if pattern_ident.ident == "router" {
                            println!("{:?}", local.init.as_ref().map(|init| &*init.expr))
                        }
                    }
                }
            }
        }
    }
}

fn get_pattern_ident(pattern: &syn::Pat) -> Option<&PatIdent> {
    if let syn::Pat::Ident(pattern_ident) = pattern {
        return Some(pattern_ident);
    }
    None
}

#[derive(Debug)]
pub struct NestInfo {
    pub path: String,
    pub router: Expr,
}

// Visitor for scanning AST and finding Router functions
struct NestVisitor {
    nests: Vec<NestInfo>,
}

impl Visit<'_> for NestVisitor {
    fn visit_expr_method_call(&mut self, node: &'_ syn::ExprMethodCall) {
        todo!()
    }
}

#[test]
fn test_nest_parsing() {
    let code = std::fs::read_to_string("test_cases/basic.rs").unwrap();

    let ast = syn::parse_file(&code).unwrap();
    find_main(ast);
}