loftspec 2.0.1

The Loft Specification Format: document model, identity, canonical bytes, hashing and conversion
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
145

//! The node tree, one struct per kind, so that containment is in the types: a Product holds
//! Feature Groups; a Feature Group holds Features and Constraints; a Feature holds Requirements
//! and Quality Attributes; a Requirement holds criteria; and a Component holds Components,
//! Constraints and Quality Attributes. Children of different kinds are kept in one list per
//! kind, the order the content view lists them in (AC-606..AC-609). Any node with a body may
//! hold Sections (AC-157). A node read without a key has none until the formatter mints one
//! (AC-209).

use crate::attributes::{
    Boundary, ConservationKind, QaKind, QualityTarget, TechnicalBinding, VerificationFate,
};
use crate::ids::{
    ComponentId, ConstraintId, CriterionId, FeatureGroupId, FeatureId, ProductId,
    QualityAttributeId, RequirementId, SectionId,
};
use std::ops::{Deref, DerefMut};

use crate::names::TagName;
use crate::slug::Slug;
use crate::statement::Statement;

/// What every node kind but the Section carries besides its name and children: a body, the tags
/// applied to it, and its Sections.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Details {
    pub body: Option<String>,
    pub tags: Vec<TagName>,
    pub sections: Vec<Section>,
}

impl Details {
    #[must_use]
    pub fn with_body(body: &str) -> Self {
        Self {
            body: Some(body.to_owned()),
            ..Self::default()
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Product {
    pub id: Option<ProductId>,
    pub slug: Slug,
    pub name: String,
    pub details: Details,
    pub feature_groups: Vec<FeatureGroup>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FeatureGroup {
    pub id: Option<FeatureGroupId>,
    pub slug: Slug,
    pub name: String,
    pub details: Details,
    pub features: Vec<Feature>,
    pub constraints: Vec<Constraint>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Feature {
    pub id: Option<FeatureId>,
    pub slug: Slug,
    pub name: String,
    pub details: Details,
    pub requirements: Vec<Requirement>,
    pub quality_attributes: Vec<QualityAttribute>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Requirement {
    pub id: Option<RequirementId>,
    pub statement: Statement,
    pub details: Details,
    pub criteria: Vec<Criterion>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Criterion {
    pub id: Option<CriterionId>,
    pub name: String,
    pub details: Details,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Component {
    pub id: Option<ComponentId>,
    pub name: String,
    pub details: Details,
    /// The boundary as written; `None` takes the parent Component's.
    pub boundary: Option<Boundary>,
    pub components: Vec<Component>,
    pub constraints: Vec<Constraint>,
    pub quality_attributes: Vec<QualityAttribute>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Constraint {
    pub id: Option<ConstraintId>,
    pub name: String,
    pub details: Details,
    pub binding: Option<TechnicalBinding>,
    pub conservation_kind: Option<ConservationKind>,
    pub verification_fate: Option<VerificationFate>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct QualityAttribute {
    pub id: Option<QualityAttributeId>,
    pub name: String,
    pub details: Details,
    pub kind: QaKind,
    pub target: QualityTarget,
    pub verification_fate: Option<VerificationFate>,
}

/// A Component with no parent, written to its own file under its slug (RQ-23, AC-757).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RootComponent {
    pub slug: Slug,
    pub component: Component,
}

impl Deref for RootComponent {
    type Target = Component;

    fn deref(&self) -> &Component {
        &self.component
    }
}

impl DerefMut for RootComponent {
    fn deref_mut(&mut self) -> &mut Component {
        &mut self.component
    }
}

/// Headed prose inside a node: a name, a body and ordered child Sections (AC-155, AC-156).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Section {
    pub id: Option<SectionId>,
    pub name: String,
    pub body: String,
    pub sections: Vec<Section>,
}