macroonz-harness 0.2.0

Safe-Rust property, fuzz, fault, schedule, mutation, network, and benchmark testing with typed evidence, reduction, and replay.
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! The name roads: how an owner and a spelling are parsed into one namespaced name, and the reference stamp every open reference is written with.

use crate::descriptor::types::{
    AuthoredTableName, CheckRef, ClaimRef, DoorRef, ExecutionSuite, MutationPointRef, NameRefusal,
    Namespace, NamespacedName, PopulationRef, ProducerName, ProjectionRef, Role, Stem,
    SubjectRoute, Tag,
};

impl Namespace {
    /// The owner one authored text declares.
    ///
    /// # Errors
    ///
    /// Returns [`NameRefusal::EmptyNamespace`] where the text is empty.
    pub const fn declared(text: &'static str) -> Result<Self, NameRefusal> {
        if text.is_empty() {
            return Err(NameRefusal::EmptyNamespace);
        }
        Ok(Self(text))
    }

    /// The owner's text.
    ///
    /// The one road out to characters, for the two places characters are what is wanted: an encoder writing a preimage, and a rendering writing a line for a person.
    #[must_use]
    pub const fn written(self) -> &'static str {
        self.0
    }
}

impl Stem {
    /// The spelling one authored text declares.
    ///
    /// # Errors
    ///
    /// Returns [`NameRefusal::EmptyStem`] where the text is empty.
    pub const fn declared(text: &'static str) -> Result<Self, NameRefusal> {
        if text.is_empty() {
            return Err(NameRefusal::EmptyStem);
        }
        Ok(Self(text))
    }

    /// The spelling's text, on the terms [`Namespace::written`] states.
    #[must_use]
    pub const fn written(self) -> &'static str {
        self.0
    }
}

impl NamespacedName {
    /// This name, parsed from the owner that declares it and the spelling it carries.
    ///
    /// # Errors
    ///
    /// Refuses an empty namespace, then an empty stem, so exactly one cause is true of any refused name.
    pub const fn named(namespace: &'static str, stem: &'static str) -> Result<Self, NameRefusal> {
        let namespace = match Namespace::declared(namespace) {
            Ok(namespace) => namespace,
            Err(refusal) => return Err(refusal),
        };
        let stem = match Stem::declared(stem) {
            Ok(stem) => stem,
            Err(refusal) => return Err(refusal),
        };
        Ok(Self { namespace, stem })
    }

    /// The owner that declares the spelling.
    #[must_use]
    pub const fn namespace(self) -> Namespace {
        self.namespace
    }

    /// The spelling itself.
    #[must_use]
    pub const fn stem(self) -> Stem {
        self.stem
    }
}

/// The two roads and the one reader every namespaced reference carries, written once and stamped over the roster.
///
/// Each reference is its own type so a claim cannot occupy a subject's seat.
/// What they share is how a name is parsed, and a hand-copied parser per newtype would be that one law standing in a dozen places.
macro_rules! namespaced_reference {
    (const $($reference:ident),+ $(,)?) => {
        $(
            namespaced_reference!(@implement $reference, pub const fn);
        )+
    };
    ($($reference:ident),+ $(,)?) => {
        $(
            namespaced_reference!(@implement $reference, pub fn);
        )+
    };
    (@implement $reference:ident, $($signature:tt)+) => {
        impl $reference {
            /// This reference, parsed from the owner that declares it and the spelling it carries.
            ///
            /// # Errors
            ///
            /// Refuses an empty namespace, then an empty stem.
            $($signature)+ named(
                namespace: &'static str,
                stem: &'static str,
            ) -> Result<Self, $crate::descriptor::NameRefusal> {
                match $crate::descriptor::NamespacedName::named(namespace, stem) {
                    Ok(name) => Ok(Self(name)),
                    Err(refusal) => Err(refusal),
                }
            }

            /// This reference, over a name already parsed.
            #[must_use]
            pub const fn over(name: $crate::descriptor::NamespacedName) -> Self {
                Self(name)
            }

            /// The namespaced name this reference carries.
            #[must_use]
            pub const fn name(self) -> $crate::descriptor::NamespacedName {
                self.0
            }
        }
    };
}

pub(crate) use namespaced_reference;

namespaced_reference!(
    AuthoredTableName,
    CheckRef,
    ClaimRef,
    DoorRef,
    ExecutionSuite,
    MutationPointRef,
    PopulationRef,
    ProducerName,
    ProjectionRef,
    Role,
    SubjectRoute,
    Tag,
);