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
|
//! This module handles parsing a `git-config` file. Generally speaking, you
//! want to use a higher abstraction such as [`File`] unless you have some
//! explicit reason to work with events instead.
//!
//! The workflow for interacting with this is to use
//! [`from_bytes()`] to obtain all parse events or tokens of the given input.
//!
//! On a higher level, one can use [`Events`] to parse all events into a set
//! of easily interpretable data type, similar to what [`File`] does.
//!
//! [`File`]: crate::File
use std::{borrow::Cow, hash::Hash};
use bstr::BStr;
mod nom;
pub use self::nom::from_bytes;
mod event;
#[path = "events.rs"]
mod events_type;
pub use events_type::{Events, FrontMatterEvents};
mod comment;
mod error;
///
pub mod section;
///
mod key;
pub use key::{parse_unvalidated as key, Key};
#[cfg(test)]
pub(crate) mod tests;
/// Syntactic events that occurs in the config. Despite all these variants
/// holding a [`Cow`] instead over a simple reference, the parser will only emit
/// borrowed `Cow` variants.
///
/// The `Cow` is used here for ease of inserting new, typically owned events as used
/// in the [`File`] struct when adding values, allowing a mix of owned and borrowed
/// values.
///
/// [`Cow`]: std::borrow::Cow
/// [`File`]: crate::File
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub enum Event<'a> {
/// A comment with a comment tag and the comment itself. Note that the
/// comment itself may contain additional whitespace and comment markers
/// at the beginning, like `# comment` or `; comment`.
Comment(Comment<'a>),
/// A section header containing the section name and a subsection, if it
/// exists. For instance, `remote "origin"` is parsed to `remote` as section
/// name and `origin` as subsection name.
SectionHeader(section::Header<'a>),
/// A name to a value in a section, like `url` in `remote.origin.url`.
SectionKey(section::Key<'a>),
/// A completed value. This may be any single-line string, including the empty string
/// if an implicit boolean value is used.
/// Note that these values may contain spaces and any special character. This value is
/// also unprocessed, so it may contain double quotes that should be
/// [normalized][crate::value::normalize()] before interpretation.
Value(Cow<'a, BStr>),
/// Represents any token used to signify a newline character. On Unix
/// platforms, this is typically just `\n`, but can be any valid newline
/// sequence. Multiple newlines (such as `\n\n`) will be merged as a single
/// newline event containing a string of multiple newline characters.
Newline(Cow<'a, BStr>),
/// Any value that isn't completed. This occurs when the value is continued
/// onto the next line by ending it with a backslash.
/// A [`Newline`][Self::Newline] event is guaranteed after, followed by
/// either a ValueDone, a Whitespace, or another ValueNotDone.
ValueNotDone(Cow<'a, BStr>),
/// The last line of a value which was continued onto another line.
/// With this it's possible to obtain the complete value by concatenating
/// the prior [`ValueNotDone`][Self::ValueNotDone] events.
ValueDone(Cow<'a, BStr>),
/// A continuous section of insignificant whitespace.
///
/// Note that values with internal whitespace will not be separated by this event,
/// hence interior whitespace there is always part of the value.
Whitespace(Cow<'a, BStr>),
/// This event is emitted when the parser counters a valid `=` character
/// separating the key and value.
/// This event is necessary as it eliminates the ambiguity for whitespace
/// events between a key and value event.
KeyValueSeparator,
}
/// A parsed section containing the header and the section events, typically
/// comprising the keys and their values.
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub struct Section<'a> {
/// The section name and subsection name, if any.
pub header: section::Header<'a>,
/// The syntactic events found in this section.
pub events: section::Events<'a>,
}
/// A parsed comment containing the comment marker and comment.
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)]
pub struct Comment<'a> {
/// The comment marker used. This is either a semicolon or octothorpe/hash.
pub tag: u8,
/// The parsed comment.
pub text: Cow<'a, BStr>,
}
/// A parser error reports the one-indexed line number where the parsing error
/// occurred, as well as the last parser node and the remaining data to be
/// parsed.
#[derive(PartialEq, Debug)]
pub struct Error {
line_number: usize,
last_attempted_parser: error::ParseNode,
parsed_until: bstr::BString,
}
|
