meta_merge_core 0.1.0

Core logic for meta_merge
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
112
113
114

use crate::extensions::token_stream::{PathTokenStreamFromStr, PathTokenStreamFromStrCollection};
use const_format::concatcp;

pub mod apply;
pub mod copy;
pub mod export;
pub mod merge;

pub mod prelude {
    use super::*;
    pub use apply::apply_outer;
    pub use copy::copy_attr_outer;
    pub use export::export_attr_outer;
    pub use merge::merge_attr_outer;
    use proc_macro2::TokenStream;
    use syn::spanned::Spanned;
    pub fn error(ts: impl Into<TokenStream>, message: &str) -> TokenStream {
        syn::Error::new(ts.into().span(), message).to_compile_error()
    }
}

type StaticStr = &'static str;
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct ApiPaths {
    root: StaticStr,
    copy_source_start: StaticStr,
    copy_source_end: StaticStr,
    merge_source_start: StaticStr,
    merge_source_end: StaticStr,
    export: StaticStr,
}

impl Default for ApiPaths {
    fn default() -> Self {
        ApiPaths::DEFAULT
    }
}

impl From<StaticStr> for ApiPaths {
    fn from(root: StaticStr) -> Self {
        Self::from_root(root)
    }
}

impl From<&ApiPaths> for ApiPaths {
    fn from(api_paths: &ApiPaths) -> Self {
        *api_paths
    }
}

macro_rules! make_path2 {
    ($self:ident, $field:ident) => {{
        PathTokenStreamFromStrCollection::new([
            $self.root(),
            PathTokenStreamFromStr::new($self.$field),
        ])
    }};
}

impl ApiPaths {
    const PRIVATE_EXPORT: &str = "__private";
    pub const DEFAULT: Self = Self {
        root: "meta_merge",
        copy_source_start: concatcp!(ApiPaths::PRIVATE_EXPORT, "::copy::source_start"),
        copy_source_end: concatcp!(ApiPaths::PRIVATE_EXPORT, "::copy::source_end"),
        merge_source_start: concatcp!(ApiPaths::PRIVATE_EXPORT, "::merge::source_start"),
        merge_source_end: concatcp!(ApiPaths::PRIVATE_EXPORT, "::merge::source_end"),
        export: concatcp!(ApiPaths::PRIVATE_EXPORT, "::export"),
    };

    pub const fn from_root(root: StaticStr) -> Self {
        Self {
            root,
            ..Self::DEFAULT
        }
    }

    const fn root(&self) -> PathTokenStreamFromStr<'_> {
        PathTokenStreamFromStr::new(self.root)
    }
    const fn copy_source_start(&self) -> PathTokenStreamFromStrCollection<'_, 2> {
        make_path2!(self, copy_source_start)
    }
    const fn copy_source_end(&self) -> PathTokenStreamFromStrCollection<'_, 2> {
        make_path2!(self, copy_source_end)
    }
    const fn merge_source_start(&self) -> PathTokenStreamFromStrCollection<'_, 2> {
        make_path2!(self, merge_source_start)
    }
    const fn merge_source_end(&self) -> PathTokenStreamFromStrCollection<'_, 2> {
        make_path2!(self, merge_source_end)
    }
    #[allow(dead_code)]
    const fn export(&self) -> PathTokenStreamFromStrCollection<'_, 2> {
        make_path2!(self, export)
    }
}

#[cfg(test)]
mod test_paths {
    use crate::extensions::token_stream::PathTokenStreamFromStrCollection;
    use crate::macro_api::ApiPaths;

    //noinspection SpellCheckingInspection
    #[allow(clippy::upper_case_acronyms)]
    type PTSFSC = PathTokenStreamFromStrCollection<'static, 2>;

    pub const API_PATHS: ApiPaths = ApiPaths::DEFAULT;
    pub const ATTR_EXPORT: PTSFSC = API_PATHS.export();
    pub const ATTR_COPY_SOURCE_START: PTSFSC = API_PATHS.copy_source_start();
    pub const ATTR_COPY_SOURCE_END: PTSFSC = API_PATHS.copy_source_end();
    pub const ATTR_MERGE_SOURCE_START: PTSFSC = API_PATHS.merge_source_start();
    pub const ATTR_MERGE_SOURCE_END: PTSFSC = API_PATHS.merge_source_end();
}