hardy7cc/pijul - Change DTGSYDX3BD6S7BSKHV6SXJPH27EM7E6E45V56KHDM3RW7WUKLDVAC

Add imara diff algorithm

Add imara histogram diff algorithm

Created by hardy7cc on March 1, 2025

DTGSYDX3BD6S7BSKHV6SXJPH27EM7E6E45V56KHDM3RW7WUKLDVAC

Dependencies

In channels

main

Change contents

Insertion in libpijul/src/diff/diff.rs at line 7 [3.801479]
[3.801683]
[3.801683]
```
    ImaraHistogram,
```
Replacement in libpijul/src/diff/diff.rs at line 22 [3.801479]
∅:D[2.5624] → [4.582:623]
B:BD[4.582] → [4.582:623]
```
    let mut dd = diffs::Replace::new(D {
```
[2.5624]
[4.623]
```
    let result = D {
```

Replacement in libpijul/src/diff/diff.rs at line 25 [3.801479]

B:BD[4.705] → [4.705:713]

∅:D[4.713] → [3.801952:802185]

B:BD[3.801952] → [3.801952:802185]

B:BD[3.802185] → [4.714:738]

∅:D[4.738] → [3.802204:802409]

B:BD[3.802204] → [3.802204:802409]

B:BD[3.802409] → [2.5625:5649]

∅:D[4.767] → [3.802428:802454]

∅:D[2.5649] → [3.802428:802454]

B:BD[3.802428] → [3.802428:802454]

    });
    match algorithm {
        Algorithm::Patience => diffs::patience::diff(
            &mut dd,
            lines_a,
            0,
            lines_a.len(),
            lines_b,
            0,
            lines_b.len(),
        )
        .unwrap_or(()),
        Algorithm::Myers => diffs::myers::diff(
            &mut dd,
            lines_a,
            0,
            lines_a.len(),
            lines_b,
            0,
            lines_b.len(),
        )
        .unwrap_or(()),
    }
    dd.into_inner()

[4.705]

[3.802454]

    };
    return match algorithm {
        Algorithm::Patience => {
            let mut dd = diffs::Replace::new(result);
            diffs::patience::diff(
                &mut dd,
                lines_a,
                0,
                lines_a.len(),
                lines_b,
                0,
                lines_b.len(),
            )
            .unwrap_or(());
            dd.into_inner()
        }
        Algorithm::Myers => {
            let mut dd = diffs::Replace::new(result);
            diffs::myers::diff(
                &mut dd,
                lines_a,
                0,
                lines_a.len(),
                lines_b,
                0,
                lines_b.len(),
            )
            .unwrap_or(());
            dd.into_inner()
        }
        Algorithm::ImaraHistogram => {
            let source = imara_diff::intern::InternedInput::new(&Lines(lines_a), &Lines(lines_b));
            imara_diff::diff(imara_diff::Algorithm::Histogram, &source, result)
        }
    };

Insertion in libpijul/src/diff/diff.rs at line 150 [3.801479]

[4.1309]

[3.804249]

    }
}
/// struct used for imara interning see InternedInput
struct Lines<'a>(&'a [Line<'a>]);
impl<'a> imara_diff::intern::TokenSource for &Lines<'a> {
    type Token = &'a Line<'a>;
    type Tokenizer = core::slice::Iter<'a, Line<'a>>;
    fn tokenize(&self) -> Self::Tokenizer {
        self.0.iter()
    }
    fn estimate_tokens(&self) -> u32 {
        self.0.len() as u32

Insertion in libpijul/src/diff/diff.rs at line 167 [3.801479]

[3.804257]

[3.804312]


impl imara_diff::Sink for D {
    type Out = D;
    fn process_change(&mut self, before: std::ops::Range<u32>, after: std::ops::Range<u32>) {
        debug!(
            "Process change: old:{:?}-{:?} new:{:?}-{:?}",
            before.start, before.end, after.start, after.end
        );
        self.r.push(Replacement {
            old: before.start as usize,
            old_len: before.len(),
            new: after.start as usize,
            new_len: after.len(),
            is_cyclic: false,
        });
    }
    fn finish(self) -> Self::Out {
        self
    }
}