git-config output to std::io::Write

Makefile

@@ -4,17 +4,6 @@ help:  ## Display this help
 
 always:
 
-##@ Publishing & Versioning
-
-try-publish-all: ## Dry-run publish all crates in the currently set version if they are not published yet.
-	(cd cargo-smart-release && cargo build --bin cargo-smart-release) && cargo-smart-release/target/debug/cargo-smart-release smart-release gitoxide
-
-try-bump-minor-version: ## Show how updating the minor version of PACKAGE=<name> would look like.
-	(cd cargo-smart-release && cargo build --bin cargo-smart-release) && cargo-smart-release/target/debug/cargo-smart-release smart-release --update-crates-index --bump minor --no-dependencies --no-publish --no-tag --no-push -v $(PACKAGE)
-
-bump-minor-version: ## Similar to try-bump-minor-version, but actually performs the operation on PACKAGE=<name>
-	(cd cargo-smart-release && cargo build --bin cargo-smart-release) && cargo-smart-release/target/debug/cargo-smart-release smart-release --update-crates-index --bump minor --no-dependencies --skip-publish --skip-tag --skip-push -v $(PACKAGE) --execute
-
 ##@ Release Builds
 
 release-all: release release-lean release-small ## all release builds
@@ -67,9 +56,6 @@ clippy: ## Run cargo clippy on all crates
 check-msrv: ## run cargo msrv to validate the current msrv requirements, similar to what CI does
 	cd git-repository && cargo check --package git-repository --no-default-features --features async-network-client,unstable,local-time-support,max-performance
 
-check-win: ## see that windows compiles, provided the x86_64-pc-windows-msvc target and cargo-xwin are present.
-	cargo xwin build --target x86_64-pc-windows-msvc  --no-default-features --features small
-
 check: ## Build all code in suitable configurations
 	cargo check --all
 	cargo check --no-default-features --features small
@@ -169,6 +155,9 @@ unit-tests: ## run all unit tests
 					&& cargo test
 	cd gitoxide-core && cargo test --lib
 
+nextest: ## run tests with `cargo nextest` (all unit-tests, no doc-tests, faster)
+	cargo nextest run --all
+
 continuous-unit-tests: ## run all unit tests whenever something changes
 	watchexec -w src $(MAKE) unit-tests
 
@@ -323,3 +312,9 @@ check-size: ## Run cargo-diet on all crates to see that they are still in bound
 fmt: ## run nightly rustfmt for its extra features, but check that it won't upset stable rustfmt
 	cargo +nightly fmt --all -- --config-path rustfmt-nightly.toml
 	cargo +stable fmt --all -- --check
+
+##@ Publishing & Versioning
+
+try-publish-all: ## Dry-run publish all crates in the currently set version if they are not published yet.
+	(cd cargo-smart-release && cargo build --bin cargo-smart-release) && cargo-smart-release/target/debug/cargo-smart-release smart-release gitoxide
+

git-config/src/file/access/mod.rs

@@ -1,3 +1,5 @@
 mod comfort;
-mod low_level;
+mod mutate;
 mod raw;
+mod read_only;
+mod write;

git-config/src/file/access/low_level/mutating.rs → git-config/src/file/access/mutate.rs

@@ -1,7 +1,6 @@
 use std::borrow::Cow;
 
-use bstr::BStr;
-
+use crate::file::rename_section;
 use crate::{
     file::{MutableSection, SectionBody},
     lookup,
@@ -51,21 +50,23 @@ impl<'event> File<'event> {
     /// # use git_config::File;
     /// # use std::convert::TryFrom;
     /// # use bstr::ByteSlice;
+    /// # use git_config::parse::section;
     /// let mut git_config = git_config::File::default();
-    /// let mut section = git_config.new_section("hello", Some("world".into()));
-    /// section.push("a".into(), b"b".as_bstr().into());
-    /// assert_eq!(git_config.to_string(), "[hello \"world\"]\n  a=b\n");
+    /// let mut section = git_config.new_section("hello", Some("world".into()))?;
+    /// section.push(section::Key::try_from("a")?, b"b".as_bstr().into());
+    /// assert_eq!(git_config.to_string(), "[hello \"world\"]\n\ta = b\n");
     /// let _section = git_config.new_section("core", None);
-    /// assert_eq!(git_config.to_string(), "[hello \"world\"]\n  a=b\n[core]\n");
+    /// assert_eq!(git_config.to_string(), "[hello \"world\"]\n\ta = b\n[core]\n");
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     pub fn new_section(
         &mut self,
         section_name: impl Into<Cow<'event, str>>,
         subsection_name: impl Into<Option<Cow<'event, str>>>,
-    ) -> MutableSection<'_, 'event> {
-        let mut section = self.push_section(section_name, subsection_name, SectionBody::default());
+    ) -> Result<MutableSection<'_, 'event>, section::header::Error> {
+        let mut section = self.push_section(section_name, subsection_name, SectionBody::default())?;
         section.push_newline();
-        section
+        Ok(section)
     }
 
     /// Removes the section, returning the events it had, if any. If multiple
@@ -131,42 +132,25 @@ impl<'event> File<'event> {
         section_name: impl Into<Cow<'event, str>>,
         subsection_name: impl Into<Option<Cow<'event, str>>>,
         section: SectionBody<'event>,
-    ) -> MutableSection<'_, 'event> {
-        let subsection_name = subsection_name.into().map(into_cow_bstr);
-        self.push_section_internal(
-            section::Header {
-                name: section::Name(into_cow_bstr(section_name.into())),
-                separator: subsection_name.is_some().then(|| Cow::Borrowed(" ".into())),
-                subsection_name,
-            },
-            section,
-        )
+    ) -> Result<MutableSection<'_, 'event>, section::header::Error> {
+        Ok(self.push_section_internal(section::Header::new(section_name, subsection_name)?, section))
     }
 
     /// Renames a section, modifying the last matching section.
     pub fn rename_section<'a>(
         &mut self,
         section_name: &str,
         subsection_name: impl Into<Option<&'a str>>,
-        new_section_name: impl Into<section::Name<'event>>,
+        new_section_name: impl Into<Cow<'event, str>>,
         new_subsection_name: impl Into<Option<Cow<'event, str>>>,
-    ) -> Result<(), lookup::existing::Error> {
+    ) -> Result<(), rename_section::Error> {
         let id = self
             .section_ids_by_name_and_subname(section_name, subsection_name.into())?
             .rev()
             .next()
             .expect("list of sections were empty, which violates invariant");
         let header = self.section_headers.get_mut(&id).expect("known section-id");
-        header.name = new_section_name.into();
-        header.subsection_name = new_subsection_name.into().map(into_cow_bstr);
-
+        *header = section::Header::new(new_section_name, new_subsection_name)?;
         Ok(())
     }
 }
-
-fn into_cow_bstr(c: Cow<'_, str>) -> Cow<'_, BStr> {
-    match c {
-        Cow::Borrowed(s) => Cow::Borrowed(s.into()),
-        Cow::Owned(s) => Cow::Owned(s.into()),
-    }
-}

git-config/src/file/access/raw.rs

@@ -1,9 +1,10 @@
 use std::{borrow::Cow, collections::HashMap};
 
-use bstr::{BStr, BString};
+use bstr::BStr;
 
+use crate::file::mutable::value::EntryData;
 use crate::{
-    file::{value::EntryData, Index, MutableMultiValue, MutableSection, MutableValue, Size},
+    file::{Index, MutableMultiValue, MutableSection, MutableValue, Size},
     lookup,
     parse::{section, Event},
     File,
@@ -24,10 +25,9 @@ impl<'event> File<'event> {
         subsection_name: Option<&str>,
         key: &str,
     ) -> Result<Cow<'_, BStr>, lookup::existing::Error> {
-        let key = section::Key(Cow::<BStr>::Borrowed(key.into()));
         let section_ids = self.section_ids_by_name_and_subname(section_name, subsection_name)?;
         for section_id in section_ids.rev() {
-            if let Some(v) = self.sections.get(&section_id).expect("known section id").value(&key) {
+            if let Some(v) = self.sections.get(&section_id).expect("known section id").value(key) {
                 return Ok(v);
             }
         }
@@ -52,23 +52,22 @@ impl<'event> File<'event> {
         let key = section::Key(Cow::<BStr>::Borrowed(key.into()));
 
         while let Some(section_id) = section_ids.next() {
-            let mut size = 0;
             let mut index = 0;
+            let mut size = 0;
             let mut found_key = false;
             for (i, event) in self
                 .sections
                 .get(&section_id)
-                .expect("sections does not have section id from section ids")
+                .expect("known section id")
                 .as_ref()
-                // todo: iter backwards
                 .iter()
                 .enumerate()
             {
                 match event {
                     Event::SectionKey(event_key) if *event_key == key => {
                         found_key = true;
-                        size = 1;
                         index = i;
+                        size = 1;
                     }
                     Event::Newline(_) | Event::Whitespace(_) | Event::ValueNotDone(_) if found_key => {
                         size += 1;
@@ -77,7 +76,10 @@ impl<'event> File<'event> {
                         found_key = false;
                         size += 1;
                     }
-                    _ => (),
+                    Event::KeyValueSeparator if found_key => {
+                        size += 1;
+                    }
+                    _ => {}
                 }
             }
 
@@ -141,12 +143,7 @@ impl<'event> File<'event> {
         let mut values = Vec::new();
         let section_ids = self.section_ids_by_name_and_subname(section_name, subsection_name)?;
         for section_id in section_ids {
-            values.extend(
-                self.sections
-                    .get(&section_id)
-                    .expect("known section id")
-                    .values(&section::Key(Cow::<BStr>::Borrowed(key.into()))),
-            );
+            values.extend(self.sections.get(&section_id).expect("known section id").values(key));
         }
 
         if values.is_empty() {
@@ -188,7 +185,7 @@ impl<'event> File<'event> {
     ///     ]
     /// );
     ///
-    /// git_config.raw_values_mut("core", None, "a")?.set_str_all("g");
+    /// git_config.raw_values_mut("core", None, "a")?.set_all("g");
     ///
     /// assert_eq!(
     ///     git_config.raw_values("core", None, "a")?,
@@ -306,10 +303,10 @@ impl<'event> File<'event> {
         section_name: &str,
         subsection_name: Option<&str>,
         key: &str,
-        new_value: BString,
+        new_value: &BStr,
     ) -> Result<(), lookup::existing::Error> {
         self.raw_value_mut(section_name, subsection_name, key)
-            .map(|mut entry| entry.set_bytes(new_value))
+            .map(|mut entry| entry.set(new_value))
     }
 
     /// Sets a multivar in a given section, optional subsection, and key value.
@@ -347,9 +344,9 @@ impl<'event> File<'event> {
     /// # use bstr::BStr;
     /// # let mut git_config = git_config::File::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     /// let new_values = vec![
-    ///     Cow::<BStr>::Borrowed("x".into()),
-    ///     Cow::<BStr>::Borrowed("y".into()),
-    ///     Cow::<BStr>::Borrowed("z".into()),
+    ///     "x".into(),
+    ///     "y".into(),
+    ///     "z".into(),
     /// ];
     /// git_config.set_raw_multi_value("core", None, "a", new_values.into_iter())?;
     /// let fetched_config = git_config.raw_values("core", None, "a")?;
@@ -368,8 +365,8 @@ impl<'event> File<'event> {
     /// # use bstr::BStr;
     /// # let mut git_config = git_config::File::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     /// let new_values = vec![
-    ///     Cow::<BStr>::Borrowed("x".into()),
-    ///     Cow::<BStr>::Borrowed("y".into()),
+    ///     "x".into(),
+    ///     "y".into(),
     /// ];
     /// git_config.set_raw_multi_value("core", None, "a", new_values.into_iter())?;
     /// let fetched_config = git_config.raw_values("core", None, "a")?;
@@ -387,21 +384,21 @@ impl<'event> File<'event> {
     /// # use bstr::BStr;
     /// # let mut git_config = git_config::File::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     /// let new_values = vec![
-    ///     Cow::<BStr>::Borrowed("x".into()),
-    ///     Cow::<BStr>::Borrowed("y".into()),
-    ///     Cow::<BStr>::Borrowed("z".into()),
-    ///     Cow::<BStr>::Borrowed("discarded".into()),
+    ///     "x".into(),
+    ///     "y".into(),
+    ///     "z".into(),
+    ///     "discarded".into(),
     /// ];
     /// git_config.set_raw_multi_value("core", None, "a", new_values)?;
     /// assert!(!git_config.raw_values("core", None, "a")?.contains(&Cow::<BStr>::Borrowed("discarded".into())));
     /// # Ok::<(), git_config::lookup::existing::Error>(())
     /// ```
-    pub fn set_raw_multi_value(
+    pub fn set_raw_multi_value<'a>(
         &mut self,
         section_name: &str,
         subsection_name: Option<&str>,
         key: &str,
-        new_values: impl IntoIterator<Item = Cow<'event, BStr>>,
+        new_values: impl IntoIterator<Item = &'a BStr>,
     ) -> Result<(), lookup::existing::Error> {
         self.raw_values_mut(section_name, subsection_name, key)
             .map(|mut v| v.set_values(new_values))

git-config/src/file/access/low_level/read_only.rs → git-config/src/file/access/read_only.rs

@@ -215,15 +215,15 @@ impl<'event> File<'event> {
     /// assert_eq!(url.map_or(0, |s| s.count()), 2);
     ///
     /// for (i, (header, body)) in config.sections_by_name_with_header("url").unwrap().enumerate() {
-    ///     let url = header.subsection_name.as_ref();
-    ///     let instead_of = body.value(&section::Key::from("insteadOf"));
+    ///     let url = header.subsection_name().unwrap();
+    ///     let instead_of = body.value("insteadOf").unwrap();
     ///
     ///     if i == 0 {
-    ///         assert_eq!(instead_of.unwrap().as_ref(), "https://github.com/");
-    ///         assert_eq!(url.unwrap().as_ref(), "ssh://[email protected]/");
+    ///         assert_eq!(instead_of.as_ref(), "https://github.com/");
+    ///         assert_eq!(url, "ssh://[email protected]/");
     ///     } else {
-    ///         assert_eq!(instead_of.unwrap().as_ref(), "https://bitbucket.org/");
-    ///         assert_eq!(url.unwrap().as_ref(), "ssh://[email protected]");
+    ///         assert_eq!(instead_of.as_ref(), "https://bitbucket.org/");
+    ///         assert_eq!(url, "ssh://[email protected]");
     ///     }
     /// }
     /// # Ok::<(), Box<dyn std::error::Error>>(())

git-config/src/file/access/write.rs

@@ -0,0 +1,35 @@
+use crate::File;
+use bstr::BString;
+
+impl File<'_> {
+    /// Serialize this type into a `BString` for convenience.
+    ///
+    /// Note that `to_string()` can also be used, but might not be lossless.
+    #[must_use]
+    pub fn to_bstring(&self) -> BString {
+        let mut buf = Vec::new();
+        self.write_to(&mut buf).expect("io error impossible");
+        buf.into()
+    }
+
+    /// Stream ourselves to the given `out`, in order to reproduce this file mostly losslessly
+    /// as it was parsed.
+    pub fn write_to(&self, mut out: impl std::io::Write) -> std::io::Result<()> {
+        for event in self.frontmatter_events.as_ref() {
+            event.write_to(&mut out)?;
+        }
+
+        for section_id in &self.section_order {
+            self.section_headers
+                .get(section_id)
+                .expect("known section-id")
+                .write_to(&mut out)?;
+
+            for event in self.sections.get(section_id).expect("known section-id").as_ref() {
+                event.write_to(&mut out)?;
+            }
+        }
+
+        Ok(())
+    }
+}