patchparser: refactor for proper parsing control and construction

Makefile

@@ -11,15 +11,18 @@ check_formatting: fmt
 cargo_test:
 	@echo "++ Run cargo $(OUR_CARGO_FLAGS) test on both crates"
 	( cd patchparser && cargo $(OUR_CARGO_FLAGS) test )
+	( cd patchparser && cargo $(OUR_CARGO_FLAGS) test --examples )
 	( cd split-patch && cargo $(OUR_CARGO_FLAGS) test )
 
 cargo_check:
 	( cd patchparser && cargo $(OUR_CARGO_FLAGS) test --color=always )
+	( cd patchparser && cargo $(OUR_CARGO_FLAGS) build --examples --color=always )
 	( cd split-patch && cargo $(OUR_CARGO_FLAGS) test --color=always )
 
 # This target is to abstract running clippy on everything (and can be run manually)
 clippy:
 	( cd patchparser && cargo clippy --color=always --all-targets --all-features $(CLIPPY_ARGS) )
+	( cd patchparser && cargo clippy --color=always --all-targets --all-features --examples $(CLIPPY_ARGS) )
 	( cd split-patch && cargo clippy --color=always --all-targets --all-features $(CLIPPY_ARGS) )
 
 # This is for use in CI.

patchparser/examples/generate_patch.rs

@@ -0,0 +1,88 @@
+use std::io::{stdout, Write};
+
+use anyhow::Result;
+use bumpalo::Bump;
+use patchparser::{
+    patch::{
+        change::Change,
+        diff::{Diff, DiffDifferences},
+        hunk::Hunk,
+        parsed_hunk::{MinimalHunkHead, ParsedHunk},
+        patch::{Patch, PatchHead, PatchHeadHeader},
+    },
+    write_to::WriteTo,
+};
+
+fn main() -> Result<()> {
+    let hunk = ParsedHunk {
+        head: MinimalHunkHead {
+            orig_start: 1,
+            patched_start: 4,
+            head_post: Some("Head".as_ref()),
+        },
+        changes: &[
+            &Change {
+                post_from_previous_change: &[],
+                pre: &["hello".into(), "world".into()],
+                minus: &["foo".into(), "bar".into()],
+                plus: &["food".into()],
+                post: &["some".into(), "post".into(), "lines".into()],
+                backslash: false,
+            },
+            &Change {
+                post_from_previous_change: &[],
+                pre: &["a new pre line".into()],
+                minus: &["ome".into(), "thing".into()],
+                plus: &["".into()],
+                post: &["some".into(), "post".into(), "lines".into()],
+                backslash: false,
+            },
+        ],
+    };
+
+    let mut out = stdout().lock();
+    hunk.write_to(&mut out)?;
+
+    writeln!(&mut out, "--------")?;
+    let bump = &Bump::new();
+    for (idx, hunk) in hunk.split_by_change(bump).iter().enumerate() {
+        let diff_path_a = format!("a/foo-{idx}");
+        let diff = Diff {
+            diff_line: "diff -- blabla".into(),
+            diff_path_a_full: Some(diff_path_a.as_str().as_ref()),
+            diff_path_b_full: Some(
+                bumpalo::format!(in bump, "b/foo-{idx}",)
+                    .into_bump_str()
+                    .as_ref(),
+            ),
+            newfile_line: None,
+            deleted_line: None,
+            similarity_line: None,
+            rename_from_line: None,
+            rename_to_line: None,
+            differences: Some(DiffDifferences {
+                index_line: Some("index line".into()),
+                minus_line: "minus line".into(),
+                plus_line: "plus line".into(),
+                hunks: &[Hunk::Parsed(hunk.clone())],
+            }),
+        };
+
+        // let patch = Patch::from_lines(lines, bump, parse_mode, handle_check_error)?;
+        let patch = Patch {
+            head: &PatchHead {
+                header: Some(&PatchHeadHeader {
+                    from_line: "From ...".into(),
+                    header_lines: &["Author: bla".into()],
+                }),
+                remaining_lines: &["Hey there!".into(), "".into()],
+            },
+            diffs: bump.alloc([diff]),
+            footer: &[],
+        };
+
+        patch.write_to(&mut out)?;
+        out.flush()?;
+    }
+    Ok(())
+}

patchparser/src/anyhow_once.rs

@@ -6,9 +6,9 @@ use anyhow::anyhow;
 /// generic error
 ///
 /// This is a work-around for the issue with lazy wrappers that errors
-/// must be stored, but anyhow::Error does not implement Clone, and
-/// Arc<anyhow::Error> is not anyhow-compatible (i.e. cannot be used
-/// with .context)
+/// must be stored, but `anyhow::Error` does not implement `Clone`,
+/// and `Arc<anyhow::Error>` is not anyhow-compatible (i.e. cannot be
+/// used with .context)
 pub struct AnyhowOnce(Mutex<Option<anyhow::Error>>);
 
 impl From<anyhow::Error> for AnyhowOnce {
@@ -18,6 +18,7 @@ impl From<anyhow::Error> for AnyhowOnce {
 }
 
 impl AnyhowOnce {
+    /// Remove the error, or panics if called a second time.
     pub fn take(&self) -> anyhow::Error {
         let mut guard = self.0.lock().expect("no panics");
         if let Some(e) = guard.take() {

patchparser/src/bumpalo_bstring.rs

@@ -11,6 +11,7 @@ impl<'bump> BString<'bump> {
         Self(Vec::new_in(bump))
     }
 
+    #[must_use]
     pub fn into_bump_slice(self) -> &'bump BStr {
         self.0.into_bump_slice().as_ref()
     }

patchparser/src/bumpalo_cow.rs

@@ -23,13 +23,20 @@ pub trait ToOwnedIn<'b> {
 
 // Also see `ReborrowIn`
 pub trait CloneIn<'b>: Sized {
+    #[must_use]
     fn clone_in(&self, bump: &'b Bump) -> Self;
 
     fn clone_from_in(&mut self, source: &Self, bump: &'b Bump)
     // where
     //     Self: ~const Destruct,
     {
-        *self = source.clone_in(bump)
+        *self = source.clone_in(bump);
+    }
+}
+
+impl<'a, T> CloneIn<'a> for &'a T {
+    fn clone_in(&self, _bump: &'a Bump) -> Self {
+        self
     }
 }
 

patchparser/src/bumpalo_utils.rs

@@ -67,3 +67,30 @@ fn t_split_before() {
         [vec!["@a"], vec!["@b"], vec!["@c", "d"], vec!["@e"],]
     );
 }
+
+/// Variant of `split_before_in` that stops on errors
+pub fn try_split_before_in<'a, 'b, T, G, E>(
+    items: &'a [T],
+    mut is_boundary: impl FnMut(&'a T) -> bool,
+    mut group_constructor: impl FnMut(&'a [T]) -> Result<G, E>,
+    bump: &'b Bump,
+) -> Result<bc::Vec<'b, G>, E> {
+    let mut finish_group = |groups: &mut bc::Vec<G>, current_group: &'a [T]| -> Result<(), E> {
+        if !current_group.is_empty() {
+            groups.push(group_constructor(current_group)?);
+        }
+        Ok(())
+    };
+
+    let mut groups = bc::Vec::new_in(bump);
+    let mut current_group_start = 0;
+    for (i, item) in items.iter().enumerate() {
+        if is_boundary(item) {
+            finish_group(&mut groups, &items[current_group_start..i])?;
+            current_group_start = i;
+        }
+    }
+    finish_group(&mut groups, &items[current_group_start..])?;
+
+    Ok(groups)
+}

patchparser/src/format_binary.rs

@@ -1,4 +1,4 @@
-//! A bit of a hack to make creating BString instances easier, from a
+//! A bit of a hack to make creating `BString` instances easier, from a
 //! mix of byte sequences and Display and Debug based format strings.
 //!
 //! Does not allocate, although it does use some indirections (could
@@ -130,7 +130,7 @@ macro_rules! ___make_bstring {
 /// Usage: use `+` to join segments, each of which can either be a
 /// format string instance in round parens (which can only deal with
 /// proper strings), or between curly braces any expression that
-/// evaluates to a byte slice / vector or BStr / BString or normal
+/// evaluates to a byte slice / vector or `BStr` / `BString` or normal
 /// string, which is then added directly as bytes.
 ///
 /// See example in the module docs.

patchparser/src/from_lines.rs

@@ -2,6 +2,11 @@ use bumpalo::Bump;
 
 use crate::line::Line;
 
+/// This trait is somewhat obsolete, because often more information is
+/// needed (e.g. for how to check parsing inconsistencies), thus other
+/// `from_lines` methods are implemented outside the trait now; also
+/// it was originally for converting stringified representations
+/// automatically back, but that has been removed.
 pub trait FromLines<'t>: Sized {
-    fn from_lines(lines: &'t [Line<'t>], bump: &'t Bump) -> Result<Self, anyhow::Error>;
+    fn from_lines(lines: &'t [Line<'t>], bump: &'t Bump) -> Result<&'t mut Self, anyhow::Error>;
 }

patchparser/src/line.rs

@@ -59,6 +59,18 @@ impl<'a> Display for Line<'a> {
     }
 }
 
+impl<'a> From<&'a str> for Line<'a> {
+    fn from(value: &'a str) -> Self {
+        Self::from_generated_content(value.into())
+    }
+}
+
+impl<'a> From<&'a BStr> for Line<'a> {
+    fn from(value: &'a BStr) -> Self {
+        Self::from_generated_content(value)
+    }
+}
+
 impl<'a> Line<'a> {
     pub fn from_lineno0_bstr(line_no0: usize, contents: &'a BStr) -> Self {
         Self { line_no0, contents }
@@ -88,6 +100,16 @@ impl<'a> Line<'a> {
         self.line_no0 = usize::MAX;
     }
 
+    /// Keep the original line number; only use for slicing, not new
+    /// content, or errors would be confusing.
+    #[must_use]
+    pub fn with_changed_contents<'b>(&self, contents: &'b BStr) -> Line<'b> {
+        Line {
+            line_no0: self.line_no0,
+            contents,
+        }
+    }
+
     /// 0-based line number; None if the line was generated (has no location)
     pub fn line_no0(&self) -> Option<usize> {
         if self.line_no0 == usize::MAX {
@@ -103,22 +125,27 @@ impl<'a> Line<'a> {
     }
 }
 
+/// Write the line string out with line ending added
+pub fn write_line_to<'a>(line: &Line<'a>, mut out: impl Write) -> Result<(), std::io::Error> {
+    out.write_all(line)?;
+    out.write_all(b"\n")
+}
+
 /// Write the line strings out with line endings added
 pub fn write_lines_to<'a>(
     lines: impl IntoIterator<Item = &'a Line<'a>>,
     mut out: impl Write,
 ) -> Result<(), std::io::Error> {
     for line in lines {
-        out.write_all(line)?;
-        out.write_all(b"\n")?;
+        write_line_to(line, &mut out)?;
     }
     Ok(())
 }
 
 pub fn read_in<'b, P: AsRef<Path>>(path: P, bump: &'b Bump) -> Result<bc::Vec<'b, u8>> {
     let mut input = std::fs::File::open(path).context("opening file for reading")?;
     let len = input.metadata()?.len();
-    let len_usize = usize::try_from(len).expect("file is too large");
+    let len_usize = usize::try_from(len).context("file is too large")?;
     let mut contents = bc::Vec::<u8>::with_capacity_in(len_usize, bump);
     unsafe {
         // Safe because we'll never read from the bytes unless they