1 files changed, 116 insertions, 0 deletions
diff --git a/vendor/gix-config/src/parse/mod.rs b/vendor/gix-config/src/parse/mod.rs
new file mode 100644
index 000000000..50363873c
--- /dev/null
+++ b/vendor/gix-config/src/parse/mod.rs
@@ -0,0 +1,116 @@
+//! This module handles parsing a `gix-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 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,
+}