concinnity 0.19.23

Asset-driven world engine
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

// The partition check for the two vocabulary namespaces, derived from the
// component registry: `components` is its `stored` group, `cook` its
// `build_only` and `resource` groups. A type added to the registry, or moved
// between its groups, fails here until the namespace it is reached through
// follows.
//
// The groups come from two lists: the runtime's (`stored` and `resource`, in
// concinnity-core) and the authoring-only one (`build_only`, in
// concinnity-cook, which the runtime tier never links). One derived check per
// list, so each name is checked for being both reachable and reachable through
// the right namespace. The entries' metadata blocks are captured and ignored.

// Bind one runtime-registry entry at a time to the marker trait its group
// carries.
macro_rules! assert_runtime_groups_are_partitioned {
    (
        stored: { $( $variant:ident => $ty:path { $($meta:tt)* } ),+ $(,)? },
        resource: { $( $rvariant:ident => $rty:path { $($rmeta:tt)* } ),+ $(,)? } $(,)?
    ) => {
        fn a_world_holds<T: concinnity_core::ecs::RuntimeComponent>() {}

        #[test]
        fn the_components_namespace_is_the_stored_group() {
            $( a_world_holds::<crate::components::$variant>(); )+
        }

        #[cfg(feature = "cook")]
        fn the_cook_compiles<T: concinnity_core::ecs::ResourceAsset>() {}

        // The five types whose authored form diverges are in both namespaces by
        // design, and are checked above through their runtime form; a bare name
        // here is the authored one, which is the only form the cook sees.
        #[cfg(feature = "cook")]
        #[test]
        fn the_cook_namespace_holds_the_compiled_resources() {
            $( the_cook_compiles::<crate::cook::$rvariant>(); )+
        }
    };
}

concinnity_core::for_each_component!(assert_runtime_groups_are_partitioned);

// The same, for the group the authoring registry owns. Gated whole: without
// `cook` there is no `cook` namespace to reach these through, and no
// concinnity-cook to read the list from.
#[cfg(feature = "cook")]
macro_rules! assert_the_build_only_group_is_reachable {
    (build_only: { $( $bvariant:ident => $bty:path { $($bmeta:tt)* } ),+ $(,)? } $(,)?) => {
        fn the_cook_expands<T: concinnity_cook::authoring::registry::BuildOnlyAsset>() {}

        #[test]
        fn the_cook_namespace_holds_the_expanded_types() {
            $( the_cook_expands::<crate::cook::$bvariant>(); )+
        }
    };
}

#[cfg(feature = "cook")]
concinnity_cook::for_each_build_only_type!(assert_the_build_only_group_is_reachable);