apivolve_generator_api 0.1.1

Api for creating generators for Apivolve, an API evolution tool that helps keep your APIs backwards compatible yet clean.
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

use ::futures::executor::block_on;
use ::semver::Version;
use ::tempdir::TempDir;

use crate::gen1::{AcceptsConfig, Evolution, GenResult, GenerationPreferences, Generator};

#[allow(unused_macros)] // it is not unused, don't know why it's not being detected
macro_rules! make_gen_test {
    ($test_name: ident, $gen_test_ident: ident, $accepts_config_expr: expr, $make_generator_expr: expr, $verify_func_ident: ident) => {
        #[test]
        fn $test_name() {
            #[inline]
            fn make_generator_expr_type_must_satisfy_this_signature<G, F>(make_generator: F) -> F
            where
                G: Generator,
                F: FnOnce(GenerationPreferences) -> Result<G, String>,
            {
                make_generator
            }

            #[inline]
            fn verify_func_ident_type_must_satisfy_this_signature<F>(verify_func: F) -> F
            where
                F: FnOnce(TempDir) -> GenResult,
            {
                verify_func
            }

            let customization: AcceptsCustomizations = $accepts_config_expr;
            let accepts_config = customization.to_accepts(
                Version::new(0, 1, 0), //TODO @mark
                GenerateInputFormat::Json,
            );
            let make_generator =
                make_generator_expr_type_must_satisfy_this_signature($make_generator_expr);
            let verify_func =
                verify_func_ident_type_must_satisfy_this_signature($verify_func_ident);
            match $gen_test_ident(accepts_config, make_generator) {
                Ok(path) => {
                    if let Err(err) = verify_func(path) {
                        panic!("apivolve generator output was not valid: {}", err)
                    }
                }
                Err(err) => panic!("apivolve generator failed: {}", err),
            };
        }
    };
}

pub(crate) use make_gen_test;

pub(crate) fn test_with_data<G, GenFn>(
    accepts_config: AcceptsConfig,
    make_generator: GenFn,
    pending: Option<Evolution>,
    versions: Vec<(Version, Evolution)>,
) -> Result<TempDir, String>
where
    G: Generator,
    GenFn: FnOnce(GenerationPreferences) -> Result<G, String>,
{
    let out_dir = TempDir::new("apivolve").unwrap();
    let gen = make_generator(GenerationPreferences {
        apivolve_version: accepts_config.apivolve_version,
        output_dir: out_dir.path().to_path_buf(),
        extra_args: vec![],
    })?;
    block_on(generator_steps(gen, pending, versions))?;
    Ok(out_dir)
}

async fn generator_steps<G: Generator>(
    mut gen: G,
    pending: Option<Evolution>,
    versions: Vec<(Version, Evolution)>,
) -> GenResult {
    if let Some(pending) = pending {
        gen.generate_pending(pending).await?;
    }
    for (version, evolution) in versions {
        gen.generate_version(version, evolution).await?;
    }
    gen.finalize().await?;
    Ok(())
}