= file.as_toml().await?;
110 |
111 | let mut sources = vec![];
112 | let mut requirements = vec![];
113 | let mut specifications = vec![];
114 |
115 | schema.load_sources(&mut sources, &root)?;
116 | schema.load_requirements(&mut requirements, &root)?;
117 | schema.load_specifications(&mut specifications, &root)?;
118 |
119 | let requirements_path = schema.requirements_path(&path, &root);
120 | let download_path = schema.download_path(&path, &root);
121 | let report = schema.report(&path, &root);
122 |
123 | Ok(Arc::new(Config {
124 | sources,
125 | requirements,
126 | specifications,
127 | requirements_path,
128 | download_path,
129 | report,
130 | }))
131 | }
132 |
133 | pub async fn default_path_and_root() -> Option<(Path, Path)> {
134 | let root = duvet_core::env::current_dir().ok()?;
135 | let path = root.join(".duvet").join("config.toml");
136 |
137 | // check to see if it exists
138 | let _ = vfs::read_metadata(&path).await.ok()?;
139 |
140 | Some((path, root))
141 | }
142 |
--------------------------------------------------------------------------------
/duvet/www/src/App.js:
--------------------------------------------------------------------------------
1 | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
2 | // SPDX-License-Identifier: Apache-2.0
3 |
4 | import { useState, default as React } from "react";
5 | import { makeStyles } from "@material-ui/core/styles";
6 | import CssBaseline from "@material-ui/core/CssBaseline";
7 | import Container from "@material-ui/core/Container";
8 | import { Switch, Route, useParams } from "react-router-dom";
9 | import { Nav } from "./nav";
10 | import { Spec, Stats } from "./spec";
11 | import { Section } from "./section";
12 | import { Link } from "./link";
13 | import specifications from "./result";
14 | import clsx from "clsx";
15 |
16 | const drawerWidth = 400;
17 |
18 | const useStyles = makeStyles((theme) => ({
19 | root: {
20 | display: "flex",
21 | },
22 | appBar: {
23 | transition: theme.transitions.create(["margin", "width"], {
24 | easing: theme.transitions.easing.sharp,
25 | duration: theme.transitions.duration.leavingScreen,
26 | }),
27 | },
28 | appBarShift: {
29 | width: `calc(100% - ${drawerWidth}px)`,
30 | marginLeft: drawerWidth,
31 | transition: theme.transitions.create(["margin", "width"], {
32 | easing: theme.transitions.easing.easeOut,
33 | duration: theme.transitions.duration.enteringScreen,
34 | }),
35 | },
36 | menuButton: {
37 | marginRight: theme.spacing(2),
38 | },
39 | hide: {
40 | display: "none",
41 | },
42 | drawer: {
43 | width: drawerWidth,
44 | flexShrink: 0,
45 | },
46 | drawerPaper: {
47 | width: drawerWidth,
48 | },
49 | drawerHeader: {
50 | display: "flex",
51 | alignItems: "center",
52 | padding: theme.spacing(0, 1),
53 | // necessary for content to be below app bar
54 | ...theme.mixins.toolbar,
55 | justifyContent: "flex-end",
56 | },
57 | content: {
58 | flexGrow: 1,
59 | padding: theme.spacing(3),
60 | transition: theme.transitions.create("margin", {
61 | easing: theme.transitions.easing.sharp,
62 | duration: theme.transitions.duration.leavingScreen,
63 | }),
64 | marginLeft: -drawerWidth,
65 | },
66 | contentShift: {
67 | transition: theme.transitions.create("margin", {
68 | easing: theme.transitions.easing.easeOut,
69 | duration: theme.transitions.duration.enteringScreen,
70 | }),
71 | marginLeft: 0,
72 | },
73 | container: {
74 | marginBottom: theme.spacing(5),
75 | },
76 | }));
77 |
78 | function App() {
79 | const classes = useStyles();
80 | const [open, setOpen] = useState(false);
81 |
82 | return (
83 |
84 |
85 |
86 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
115 |
116 |
{spec.title}
117 |
118 |
119 |
120 | ));
121 | }
122 |
123 | function SpecRoute() {
124 | const { specid } = useParams();
125 | const spec = specifications[specid];
126 | if (!spec) return "spec not found";
127 | return ;
128 | }
129 |
130 | function SectionRoute() {
131 | const { specid, sectionid } = useParams();
132 |
133 | const spec = specifications[specid];
134 | if (!spec) return "spec not found";
135 |
136 | const section = spec.sections[sectionid];
137 | if (!section) return "section not found";
138 |
139 | return ;
140 | }
141 |
142 | export default App;
143 |
--------------------------------------------------------------------------------
/duvet/src/specification/markdown/snapshots/duvet__specification__markdown__tests__list_example__tokens.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: duvet/src/specification/markdown/tests.rs
3 | expression: "super :: tokens(& contents).collect :: < Vec < _ >> ()"
4 | ---
5 | [
6 | Content {
7 | value: "",
8 | line: 1,
9 | },
10 | Section {
11 | id: None,
12 | title: "List example",
13 | level: 1,
14 | line: 2,
15 | },
16 | Content {
17 | value: "",
18 | line: 3,
19 | },
20 | Content {
21 | value: "Here is a list:",
22 | line: 4,
23 | },
24 | Break {
25 | line: 5,
26 | },
27 | Content {
28 | value: "* Item 1",
29 | line: 5,
30 | },
31 | Break {
32 | line: 5,
33 | },
34 | Break {
35 | line: 6,
36 | },
37 | Content {
38 | value: "* Item 2",
39 | line: 6,
40 | },
41 | Break {
42 | line: 7,
43 | },
44 | Content {
45 | value: " * Item 2.1",
46 | line: 7,
47 | },
48 | Break {
49 | line: 7,
50 | },
51 | Break {
52 | line: 8,
53 | },
54 | Content {
55 | value: "* Item 3",
56 | line: 8,
57 | },
58 | Break {
59 | line: 9,
60 | },
61 | Content {
62 | value: " * Item 3.1",
63 | line: 9,
64 | },
65 | Break {
66 | line: 10,
67 | },
68 | Content {
69 | value: " * Item 3.1.1",
70 | line: 10,
71 | },
72 | Break {
73 | line: 10,
74 | },
75 | Break {
76 | line: 11,
77 | },
78 | Content {
79 | value: " * Item 3.1.2",
80 | line: 11,
81 | },
82 | Break {
83 | line: 11,
84 | },
85 | Break {
86 | line: 12,
87 | },
88 | Content {
89 | value: " * Item 3.2",
90 | line: 12,
91 | },
92 | Break {
93 | line: 12,
94 | },
95 | Content {
96 | value: "",
97 | line: 13,
98 | },
99 | Content {
100 | value: "Here is a numbered list:",
101 | line: 14,
102 | },
103 | Break {
104 | line: 15,
105 | },
106 | Content {
107 | value: "1. Item 1",
108 | line: 15,
109 | },
110 | Break {
111 | line: 15,
112 | },
113 | Break {
114 | line: 16,
115 | },
116 | Content {
117 | value: "2. Item 2",
118 | line: 16,
119 | },
120 | Break {
121 | line: 16,
122 | },
123 | Break {
124 | line: 17,
125 | },
126 | Content {
127 | value: "3. Item 3",
128 | line: 17,
129 | },
130 | Break {
131 | line: 17,
132 | },
133 | Content {
134 | value: "",
135 | line: 18,
136 | },
137 | Content {
138 | value: "Here is a list with content:",
139 | line: 19,
140 | },
141 | Break {
142 | line: 20,
143 | },
144 | Content {
145 | value: "* Item",
146 | line: 20,
147 | },
148 | Content {
149 | value: " More content",
150 | line: 21,
151 | },
152 | Content {
153 | value: "",
154 | line: 22,
155 | },
156 | Content {
157 | value: " Other content",
158 | line: 23,
159 | },
160 | Content {
161 | value: "",
162 | line: 24,
163 | },
164 | Break {
165 | line: 25,
166 | },
167 | Content {
168 | value: " * Testing",
169 | line: 25,
170 | },
171 | Content {
172 | value: "",
173 | line: 26,
174 | },
175 | Content {
176 | value: " Other test",
177 | line: 27,
178 | },
179 | Break {
180 | line: 27,
181 | },
182 | Content {
183 | value: "",
184 | line: 28,
185 | },
186 | Content {
187 | value: "Testing 123",
188 | line: 29,
189 | },
190 | Content {
191 | value: "",
192 | line: 30,
193 | },
194 | Break {
195 | line: 31,
196 | },
197 | Content {
198 | value: "* Item",
199 | line: 31,
200 | },
201 | Content {
202 | value: "More content",
203 | line: 32,
204 | },
205 | Break {
206 | line: 32,
207 | },
208 | ]
209 |
--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
1 | on:
2 | push:
3 | branches:
4 | - main
5 | pull_request:
6 | branches:
7 | - main
8 |
9 | schedule:
10 | # run every morning at 10am Pacific Time
11 | - cron: '0 17 * * *'
12 |
13 | name: ci
14 |
15 | env:
16 | CARGO_INCREMENTAL: 0
17 | CARGO_NET_RETRY: 10
18 | RUSTUP_MAX_RETRIES: 10
19 | RUST_BACKTRACE: 1
20 | # Pin the nightly toolchain to prevent breakage.
21 | # This should be occasionally updated.
22 | RUST_NIGHTLY_TOOLCHAIN: nightly-2025-11-09
23 |
24 | jobs:
25 | env:
26 | runs-on: ubuntu-latest
27 | outputs:
28 | rust-versions: ${{ steps.definitions.outputs.versions }}
29 | msrv: ${{ steps.definitions.outputs.msrv }}
30 | steps:
31 | - uses: actions/checkout@v6
32 | - name: Evaluate definitions
33 | id: definitions
34 | run: |
35 | rustup show active-toolchain
36 | export MSRV=$(rustup show active-toolchain | awk -F'-' '{print $1}')
37 | if [ -z "$MSRV" ]; then
38 | echo "Error: MSRV did not parse correctly"
39 | exit 1
40 | fi
41 | echo "msrv=$MSRV" >> "$GITHUB_OUTPUT"
42 | export RAW_VERSIONS="stable beta $RUST_NIGHTLY_TOOLCHAIN $MSRV"
43 | export VERSIONS=$(echo $RAW_VERSIONS | jq -scR 'rtrimstr("\n")|split(" ")|.')
44 | echo "versions=$VERSIONS" >> "$GITHUB_OUTPUT"
45 |
46 | checks:
47 | runs-on: ubuntu-latest
48 | steps:
49 | - uses: actions/checkout@v6
50 |
51 | - name: Install rustfmt toolchain
52 | run: |
53 | rustup toolchain install ${{ env.RUST_NIGHTLY_TOOLCHAIN }} --profile minimal --component rustfmt
54 | rustup override set ${{ env.RUST_NIGHTLY_TOOLCHAIN }}
55 |
56 | - name: Install clippy toolchain
57 | run: |
58 | rustup toolchain install stable --profile minimal --component clippy
59 | rustup override set stable
60 |
61 | - name: Run checks
62 | run: |
63 | cargo xtask checks --rustfmt-toolchain ${{ env.RUST_NIGHTLY_TOOLCHAIN }}
64 |
65 | udeps:
66 | runs-on: ubuntu-latest
67 | steps:
68 | - uses: actions/checkout@v6
69 | with:
70 | submodules: true
71 |
72 | - name: Install toolchain
73 | id: toolchain
74 | run: |
75 | rustup toolchain install ${{ env.RUST_NIGHTLY_TOOLCHAIN }} --profile minimal
76 | rustup override set ${{ env.RUST_NIGHTLY_TOOLCHAIN }}
77 |
78 | - uses: camshaft/rust-cache@v1
79 |
80 | - uses: camshaft/install@v1
81 | with:
82 | crate: cargo-udeps
83 |
84 | - name: Cache node_modules
85 | uses: actions/cache@v4.3.0
86 | continue-on-error: true
87 | with:
88 | path: duvet/www/node_modules
89 | key: node-modules-${{ runner.os }}-${{ hashFiles('duvet/www/package-lock.json') }}
90 |
91 | - name: Build script.js
92 | run: |
93 | cargo xtask build
94 |
95 | - name: Run cargo udeps
96 | run: cargo udeps --workspace --all-targets
97 | env:
98 | RUSTC_WRAPPER: ""
99 |
100 | test:
101 | runs-on: ${{ matrix.os }}
102 | needs: env
103 | strategy:
104 | matrix:
105 | rust: ${{ fromJson(needs.env.outputs.rust-versions) }}
106 | os: [ubuntu-latest, macOS-latest]
107 | steps:
108 | - uses: actions/checkout@v6
109 | with:
110 | lfs: true
111 |
112 | - name: Install toolchain
113 | id: toolchain
114 | run: |
115 | rustup toolchain install ${{ matrix.rust }}
116 | rustup override set ${{ matrix.rust }}
117 |
118 | - uses: camshaft/rust-cache@v1
119 | with:
120 | key: ${{ matrix.target }}
121 |
122 | - name: Cache node_modules
123 | uses: actions/cache@v4.3.0
124 | continue-on-error: true
125 | with:
126 | path: duvet/www/node_modules
127 | key: node-modules-${{ runner.os }}-${{ hashFiles('duvet/www/package-lock.json') }}
128 |
129 | - name: Run tests
130 | run: |
131 | cargo xtask test
132 |
133 | action: # make sure the action works on a clean machine without building
134 | runs-on: ubuntu-latest
135 | steps:
136 | - uses: actions/checkout@v6
137 | - uses: ./
138 | - name: duvet help
139 | run: duvet --help
140 | - name: duvet report
141 | run: duvet report
142 |
--------------------------------------------------------------------------------
/duvet/src/specification/ietf/parser.rs:
--------------------------------------------------------------------------------
1 | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
2 | // SPDX-License-Identifier: Apache-2.0
3 |
4 | use super::tokenizer::Token;
5 | use core::fmt;
6 | use duvet_core::file::Slice;
7 |
8 | pub fn parse>(tokens: T) -> Parser {
9 | Parser {
10 | section: None,
11 | tokens: tokens.into_iter(),
12 | }
13 | }
14 |
15 | pub struct Parser {
16 | section: Option,
17 | tokens: T,
18 | }
19 |
20 | pub struct Section {
21 | pub id: Id,
22 | pub title: Slice,
23 | pub lines: Vec,
24 | }
25 |
26 | pub enum Id {
27 | Section(Slice),
28 | Appendix(Slice),
29 | NamedSection(Slice),
30 | }
31 |
32 | impl fmt::Display for Id {
33 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34 | match self {
35 | Id::Section(id) => write!(f, "section-{id}"),
36 | Id::Appendix(id) => write!(f, "appendix-{id}"),
37 | Id::NamedSection(title) => write!(f, "name-{}", slug::slugify(title)),
38 | }
39 | }
40 | }
41 |
42 | impl Section {
43 | fn push(&mut self, value: Slice) {
44 | // don't push an empty first line
45 | if self.lines.is_empty() && value.trim().is_empty() {
46 | return;
47 | }
48 |
49 | self.lines.push(value);
50 | }
51 | }
52 |
53 | impl> Parser {
54 | fn on_token(&mut self, token: Token) -> Option {
55 | match token {
56 | Token::Section { id, title, line: _ } => {
57 | let prev = self.flush();
58 |
59 | self.section = Some(Section {
60 | id: Id::Section(id),
61 | title,
62 | lines: vec![],
63 | });
64 |
65 | prev
66 | }
67 | Token::Appendix { id, title, line: _ } => {
68 | let prev = self.flush();
69 |
70 | self.section = Some(Section {
71 | id: Id::Appendix(id),
72 | title,
73 | lines: vec![],
74 | });
75 |
76 | prev
77 | }
78 | Token::NamedSection { title, line: _ } => {
79 | let prev = self.flush();
80 |
81 | self.section = Some(Section {
82 | id: Id::NamedSection(title.clone()),
83 | title,
84 | lines: vec![],
85 | });
86 |
87 | prev
88 | }
89 | Token::Break {
90 | value,
91 | ty: _,
92 | line: _,
93 | } => {
94 | if let Some(section) = self.section.as_mut() {
95 | // just get the line offset
96 | let trimmed = &value[0..0];
97 | let value = value.file().substr(trimmed).unwrap();
98 | section.push(value);
99 | }
100 |
101 | None
102 | }
103 | Token::Content { value, line: _ } => {
104 | if let Some(section) = self.section.as_mut() {
105 | section.push(value);
106 | }
107 |
108 | None
109 | }
110 | Token::Header { value: _, line: _ } => {
111 | // ignore headers
112 | None
113 | }
114 | }
115 | }
116 |
117 | fn flush(&mut self) -> Option {
118 | let mut section = core::mem::take(&mut self.section)?;
119 |
120 | // trim any trailing lines
121 | loop {
122 | let Some(line) = section.lines.last() else {
123 | break;
124 | };
125 |
126 | if !line.trim().is_empty() {
127 | break;
128 | }
129 |
130 | section.lines.pop();
131 | }
132 |
133 | Some(section)
134 | }
135 | }
136 |
137 | impl> Iterator for Parser {
138 | type Item = Section;
139 |
140 | fn next(&mut self) -> Option {
141 | loop {
142 | let Some(token) = self.tokens.next() else {
143 | return self.flush();
144 | };
145 | if let Some(section) = self.on_token(token) {
146 | return Some(section);
147 | }
148 | }
149 | }
150 | }
151 |
--------------------------------------------------------------------------------
/duvet/src/report/status.rs:
--------------------------------------------------------------------------------
1 | // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
2 | // SPDX-License-Identifier: Apache-2.0
3 |
4 | use super::Reference;
5 | use crate::annotation::AnnotationType;
6 | use core::ops::Deref;
7 | use std::collections::{BTreeMap, BTreeSet, HashSet};
8 |
9 | // TODO use a real interval set
10 | type IntervalSet = HashSet;
11 |
12 | type AnnotationId = usize;
13 |
14 | #[derive(Debug, Default)]
15 | pub struct StatusMap(BTreeMap);
16 |
17 | impl Deref for StatusMap {
18 | type Target = BTreeMap;
19 |
20 | fn deref(&self) -> &Self::Target {
21 | &self.0
22 | }
23 | }
24 |
25 | impl StatusMap {
26 | pub(super) fn populate(&mut self, references: &[Reference]) {
27 | let mut specs: BTreeMap> = BTreeMap::new();
28 | let mut coverage: BTreeMap> = BTreeMap::new();
29 |
30 | // first build up a map of all of the references at any given offset
31 | for r in references {
32 | if r.annotation.anno != AnnotationType::Spec {
33 | for offset in r.start()..r.end() {
34 | coverage.entry(offset).or_default().push(r);
35 | }
36 | } else {
37 | specs.entry(r.annotation.id).or_default().push(r);
38 | }
39 | }
40 |
41 | self.0 = specs
42 | .iter()
43 | .map(|(anno_id, refs)| {
44 | let mut spec = SpecReport::default();
45 | for r in refs {
46 | for offset in r.start()..r.end() {
47 | spec.insert(offset, r);
48 | }
49 | for (offset, refs) in coverage.range(r.start()..r.end()) {
50 | for r in refs {
51 | spec.insert(*offset, r);
52 | spec.related.insert(r.annotation.id);
53 | }
54 | }
55 | }
56 | (*anno_id, spec.finish())
57 | })
58 | .collect();
59 | }
60 | }
61 |
62 | #[derive(Debug, Default)]
63 | pub struct Spec {
64 | pub spec: usize,
65 | pub incomplete: usize,
66 | pub citation: usize,
67 | pub implication: usize,
68 | pub test: usize,
69 | pub exception: usize,
70 | pub todo: usize,
71 | pub related: BTreeSet,
72 | }
73 |
74 | #[derive(Debug, Default)]
75 | pub struct SpecReport {
76 | spec_offsets: IntervalSet,
77 | citation_offsets: IntervalSet,
78 | implication_offsets: IntervalSet,
79 | test_offsets: IntervalSet,
80 | exception_offsets: IntervalSet,
81 | todo_offsets: IntervalSet,
82 | related: BTreeSet,
83 | }
84 |
85 | impl SpecReport {
86 | fn insert(&mut self, offset: usize, reference: &Reference) {
87 | match reference.annotation.anno {
88 | AnnotationType::Spec => &mut self.spec_offsets,
89 | AnnotationType::Citation => &mut self.citation_offsets,
90 | AnnotationType::Implication => &mut self.implication_offsets,
91 | AnnotationType::Test => &mut self.test_offsets,
92 | AnnotationType::Exception => &mut self.exception_offsets,
93 | AnnotationType::Todo => &mut self.todo_offsets,
94 | }
95 | .insert(offset);
96 | }
97 |
98 | fn finish(mut self) -> Spec {
99 | let spec = self.spec_offsets.len();
100 |
101 | // exceptions automatically mark the section as complete
102 | for offset in self.exception_offsets.iter() {
103 | self.spec_offsets.remove(offset);
104 | }
105 |
106 | // implications automatically mark the section as complete
107 | for offset in self.implication_offsets.iter() {
108 | self.spec_offsets.remove(offset);
109 | }
110 |
111 | // an offset needs to be both cited and tested to be complete
112 | for offset in self.citation_offsets.union(&self.test_offsets) {
113 | self.spec_offsets.remove(offset);
114 | }
115 |
116 | Spec {
117 | spec,
118 | incomplete: self.spec_offsets.len(),
119 | citation: self.citation_offsets.len(),
120 | implication: self.implication_offsets.len(),
121 | test: self.test_offsets.len(),
122 | exception: self.exception_offsets.len(),
123 | todo: self.todo_offsets.len(),
124 | related: self.related,
125 | }
126 | }
127 | }
128 |
--------------------------------------------------------------------------------