Struct DiffSlicer 

pub struct DiffSlicer { /* private fields */ }

Condenses unified diffs.

Example

use boundgraph_slice::{DiffSlicer, MemoryStore, Raw, Slicer};

let patch = "\
diff --git a/src/main.rs b/src/main.rs
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,3 @@
 fn main() {
-    println!(\"old\");
+    println!(\"new\");
 }
";

let condensate = tokio::runtime::Builder::new_current_thread()
    .build()?
    .block_on(DiffSlicer::new().condense(&Raw::new(patch), 400, &MemoryStore::new()))?;

assert!(!condensate.lossy, "a small patch survives whole");

Implementations

impl DiffSlicer

pub fn new() -> Self

A slicer keeping three context lines, trimming to none under pressure.

pub fn context(self, context: usize, min_context: usize) -> Self

Keep at most context unchanged lines around each change, and never trim below min_context.

A floor above zero is for a reviewer who needs to see where a change landed even at the cost of dropping more hunks.

pub fn parse(text: &str) -> Vec<FileDiff>

Parse a unified diff into files and hunks.

Tolerant by design: a patch with an unrecognised header line is still mostly a patch, and refusing the whole thing over one line git added in a version nobody here has seen would be worse than ignoring it.

Trait Implementations

impl Clone for DiffSlicer

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for DiffSlicer

impl Debug for DiffSlicer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DiffSlicer

fn default() -> Self

Returns the “default value” for a type.

impl Slicer for DiffSlicer

fn id(&self) -> SlicerId

Which slicer this is, and at what version.

fn slice<'life0, 'life1, 'async_trait>( &'life0 self, raw: &'life1 Raw, cap: usize, ) -> Pin<Box<dyn Future<Output = Result<Slice, SliceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Produce the summary. The part an implementation writes.

fn counter(&self) -> &dyn TokenCount

How this slicer counts tokens.

fn minimum_cap(&self) -> usize

The least a summary from this slicer can cost.

fn condense<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, raw: &'life1 Raw, cap: usize, store: &'life2 dyn Store, ) -> Pin<Box<dyn Future<Output = Result<Condensate, SliceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Preserve the original, slice it, and check the result fits.