fmtview 0.3.5

Fast CLI viewer for highlighting, search, and diffs across JSON, JSONL, markup, Markdown, TOML, text, and Jinja
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 anyhow::Result;

use crate::{input::InputSource, load::LoadPlan, profile::TypeProfile, transform::FormatOptions};

use super::{
    DiffModel, LazyRecordDiff,
    external::{format_diff_inputs, run_external_diff_view_model},
};

pub(crate) enum DiffView {
    Eager(DiffModel),
    Lazy(Box<LazyRecordDiff>),
}

impl DiffView {
    pub(crate) fn model(&self) -> &DiffModel {
        match self {
            Self::Eager(model) => model,
            Self::Lazy(diff) => diff.model(),
        }
    }

    pub(crate) fn preload(
        &mut self,
        max_records: usize,
        budget: std::time::Duration,
    ) -> Result<bool> {
        match self {
            Self::Eager(_) => Ok(false),
            Self::Lazy(diff) => diff.preload(max_records, budget),
        }
    }

    pub(crate) fn is_complete(&self) -> bool {
        match self {
            Self::Eager(_) => true,
            Self::Lazy(diff) => diff.is_complete(),
        }
    }
}

pub(crate) fn diff_view(
    left: &InputSource,
    right: &InputSource,
    options: &FormatOptions,
) -> Result<DiffView> {
    if should_use_lazy_record_diff(left, right, options)? {
        return Ok(DiffView::Lazy(Box::new(LazyRecordDiff::new(
            left, right, *options,
        )?)));
    }

    let formatted = format_diff_inputs(left, right, options)?;
    Ok(DiffView::Eager(run_external_diff_view_model(
        left,
        right,
        &formatted.left,
        &formatted.right,
    )?))
}

fn should_use_lazy_record_diff(
    left: &InputSource,
    right: &InputSource,
    options: &FormatOptions,
) -> Result<bool> {
    Ok(
        TypeProfile::resolve(left, options)?.load == LoadPlan::LazyTransformedRecords
            && TypeProfile::resolve(right, options)?.load == LoadPlan::LazyTransformedRecords,
    )
}