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
pub mod gen;
mod lines;
use std::collections::BTreeMap;
use std::{fmt, io};
use futures_util::{TryStream, TryStreamExt};
use nom_supreme::final_parser::Location;
use thiserror::Error;
use self::lines::{file_line, version_line};
pub use self::lines::{FileLine, VersionLine};
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum Section {
Version,
Files,
}
impl Section {
fn as_header(&self) -> &'static str {
match self {
Self::Files => "[files]",
Self::Version => "[version]",
}
}
}
#[derive(Debug, Error)]
pub enum Error {
MissingHeader(&'static str),
MissingVersionLine,
ExpectedHeader(&'static str, String),
IO(#[from] std::io::Error),
Nom(#[from] nom::error::Error<Location>),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::MissingHeader(h) => write!(f, "Missing '{}' header", h),
Self::ExpectedHeader(h, line) => write!(f, "Expected '{}' header, got {:?}", h, line),
Self::MissingVersionLine => write!(f, "Missing version line"),
Self::IO(_) => write!(f, "I/O error"),
Self::Nom(_) => write!(f, "Parser error"),
}
}
}
pub type Result<T> = std::result::Result<T, Error>;
async fn expect_header<L>(lines: &mut L, section: Section) -> Result<()>
where
L: TryStream<Ok = String, Error = io::Error> + Unpin,
{
let header = section.as_header();
let res = lines.try_next().await?;
let line = res.ok_or(Error::MissingHeader(header))?;
if line != header {
return Err(Error::ExpectedHeader(header, line));
}
Ok(())
}
async fn read_index_version<L>(lines: &mut L) -> Result<VersionLine>
where
L: TryStream<Ok = String, Error = io::Error> + Unpin,
{
expect_header(lines, Section::Version).await?;
let line = lines.try_next().await?.ok_or(Error::MissingVersionLine)?;
let version = version_line(&line)?;
Ok(version)
}
pub struct Manifest {
pub version: VersionLine,
pub files: BTreeMap<String, FileLine>,
}
pub async fn load_manifest<L>(lines: &mut L) -> Result<Manifest>
where
L: TryStream<Ok = String, Error = io::Error> + Unpin,
{
let mut files = BTreeMap::new();
let version = read_index_version(lines).await?;
expect_header(lines, Section::Files).await?;
while let Some(item) = lines.try_next().await? {
let line = item;
let (filename, data) = file_line(&line)?;
files.insert(filename.to_owned(), data);
}
Ok(Manifest { version, files })
}