debian_watch/
lib.rs

1#![deny(missing_docs)]
2//! Formatting-preserving parser and editor for Debian watch files
3//!
4//! # Example
5//!
6//! ```rust
7//! let wf = debian_watch::WatchFile::new(None);
8//! assert_eq!(wf.version(), debian_watch::DEFAULT_VERSION);
9//! assert_eq!("", wf.to_string());
10//!
11//! let wf = debian_watch::WatchFile::new(Some(4));
12//! assert_eq!(wf.version(), 4);
13//! assert_eq!("version=4\n", wf.to_string());
14//!
15//! let wf: debian_watch::WatchFile = r#"version=4
16//! opts=foo=blah https://foo.com/bar .*/v?(\d\S+)\.tar\.gz
17//! "#.parse().unwrap();
18//! assert_eq!(wf.version(), 4);
19//! assert_eq!(wf.entries().collect::<Vec<_>>().len(), 1);
20//! let entry = wf.entries().next().unwrap();
21//! assert_eq!(entry.opts(), maplit::hashmap! {
22//!    "foo".to_string() => "blah".to_string(),
23//! });
24//! assert_eq!(&entry.url(), "https://foo.com/bar");
25//! assert_eq!(entry.matching_pattern().as_deref(), Some(".*/v?(\\d\\S+)\\.tar\\.gz"));
26//! ```
27
28mod lex;
29mod parse;
30
31/// Any watch files without a version are assumed to be
32/// version 1.
33pub const DEFAULT_VERSION: u32 = 1;
34
35mod types;
36
37pub use types::*;
38
39/// Let's start with defining all kinds of tokens and
40/// composite nodes.
41#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
42#[allow(non_camel_case_types, missing_docs, clippy::upper_case_acronyms)]
43#[repr(u16)]
44pub(crate) enum SyntaxKind {
45    KEY = 0,
46    VALUE,
47    EQUALS,
48    QUOTE,
49    COMMA,
50    CONTINUATION,
51    NEWLINE,
52    WHITESPACE, // whitespaces is explicit
53    COMMENT,    // comments
54    ERROR,      // as well as errors
55
56    // composite nodes
57    ROOT,             // The entire file
58    VERSION,          // "version=x\n"
59    ENTRY,            // "opts=foo=blah https://foo.com/bar .*/v?(\d\S+)\.tar\.gz\n"
60    OPTS_LIST,        // "opts=foo=blah"
61    OPTION,           // "foo=blah"
62    URL,              // "https://foo.com/bar"
63    MATCHING_PATTERN, // ".*/v?(\d\S+)\.tar\.gz"
64    VERSION_POLICY,   // "debian"
65    SCRIPT,           // "uupdate"
66}
67
68/// Convert our `SyntaxKind` into the rowan `SyntaxKind`.
69impl From<SyntaxKind> for rowan::SyntaxKind {
70    fn from(kind: SyntaxKind) -> Self {
71        Self(kind as u16)
72    }
73}
74
75pub use crate::parse::Entry;
76pub use crate::parse::WatchFile;
77
78#[cfg(test)]
79mod tests {
80    #[test]
81    fn test_create_watchfile() {
82        let wf = super::WatchFile::new(None);
83        assert_eq!(wf.version(), super::DEFAULT_VERSION);
84
85        assert_eq!("", wf.to_string());
86
87        let wf = super::WatchFile::new(Some(4));
88        assert_eq!(wf.version(), 4);
89
90        assert_eq!("version=4\n", wf.to_string());
91    }
92
93    #[test]
94    fn test_set_version() {
95        let mut wf = super::WatchFile::new(Some(4));
96        assert_eq!(wf.version(), 4);
97
98        wf.set_version(5);
99        assert_eq!(wf.version(), 5);
100        assert_eq!("version=5\n", wf.to_string());
101
102        // Test setting version on a file without version
103        let mut wf = super::WatchFile::new(None);
104        assert_eq!(wf.version(), super::DEFAULT_VERSION);
105
106        wf.set_version(4);
107        assert_eq!(wf.version(), 4);
108        assert_eq!("version=4\n", wf.to_string());
109    }
110
111    #[test]
112    fn test_set_version_on_parsed() {
113        // Test that parsed WatchFiles can be mutated
114        let mut wf: super::WatchFile = "version=4\n".parse().unwrap();
115        assert_eq!(wf.version(), 4);
116
117        wf.set_version(5);
118        assert_eq!(wf.version(), 5);
119        assert_eq!("version=5\n", wf.to_string());
120
121        // Test setting version on a parsed file without version
122        let mut wf: super::WatchFile = "".parse().unwrap();
123        assert_eq!(wf.version(), super::DEFAULT_VERSION);
124
125        wf.set_version(4);
126        assert_eq!(wf.version(), 4);
127        assert_eq!("version=4\n", wf.to_string());
128    }
129}