diffs-rs 0.1.0

Fast terminal diff viewer and embeddable Rust diff engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use super::*;
use crate::reading::{SearchMatch, SearchRead, SearchStart, literal, search::Position};

impl Engine {
    /// Captures diff text and the current reading origin. It does not start a worker.
    /// The caller owns cancellation/join and must reject superseded query replies.
    pub fn search_read(&mut self, query: String) -> Result<SearchRead> {
        literal::validate(&query)?;
        let selected = self.selected_source()?;
        let domain = self.search_domain()?;
        let app = self
            .app
            .as_ref()
            .context("Review source is not available")?;
        let preferred = selected
            .map_or(if app.old_side { Side::Old } else { Side::New }, |source| {
                source.side
            });
        let start = if let Some(row) = app.row(app.cursor.row) {
            if let (Some(selected), RowKind::Code { left, right }) = (selected, row.kind) {
                let source = if selected.side == Side::Old {
                    left
                } else {
                    right
                }
                .context("Selected search source is not available")?;
                SearchStart::At(Position {
                    file: row.file,
                    row: domain.files[row.file]
                        .order
                        .row_for_source(source)
                        .context("Selected source is outside search scope")?,
                    byte: 0,
                })
            } else {
                SearchStart::AfterRow {
                    display: app
                        .view
                        .reading_order(app.doc.files[row.file].clone(), app.split()),
                    row: app.cursor.row - app.view.file_row(&app.doc, row.file, app.split()),
                }
            }
        } else {
            SearchStart::At(Position::default())
        };
        SearchRead::new(domain, query, start, preferred)
    }

    /// Selects a validated match without accepting another query's late reply for the caller.
    pub fn show_search_match(&mut self, found: &SearchMatch) -> Result<()> {
        found.check(self.id)?;
        let app = self.app.as_mut().context("The review is closed")?;
        app.reveal_source(
            found.hit.source,
            found.display.start,
            found.location().side == Side::Old,
        )?;
        app.search_match = Some(found.clone());
        self.changed(InputEffect::Highlight);
        self.track_selection(true)?;
        Ok(())
    }

    pub fn clear_search_match(&mut self) {
        if let Some(app) = &mut self.app
            && app.search_match.take().is_some()
        {
            self.changed(InputEffect::Redraw);
        }
    }
}