iwe 0.15.0

IWE CLI utility
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::path::{Path, PathBuf};

use diwe::config::Configuration;
use diwe::fs::new_for_path;
use diwe::graph_from_path;
use serde::Serialize;

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize)]
pub struct Churn {
    pub changed: usize,
    pub total: usize,
}

impl Churn {
    pub fn render(&self) -> String {
        if self.total == 0 {
            return "no files".to_string();
        }
        format!("{}/{} files", self.changed, self.total)
    }
}

fn library_path(root: &Path, config: &Configuration) -> PathBuf {
    if config.library.path.is_empty() {
        root.to_path_buf()
    } else {
        root.join(&config.library.path)
    }
}

pub fn measure(root: &Path, config: &Configuration) -> Churn {
    let library = library_path(root, config);
    if !library.exists() {
        return Churn::default();
    }

    let before = new_for_path(&library, config.format);
    if before.is_empty() {
        return Churn::default();
    }

    let graph = graph_from_path(
        &library,
        false,
        config.format_options(),
        config.library.frontmatter_document_title.clone(),
    );
    let after = graph.export();

    let changed = before
        .iter()
        .filter(|(key, content)| {
            after
                .get(*key)
                .is_some_and(|normalized| normalized != *content)
        })
        .count();

    Churn {
        changed,
        total: before.len(),
    }
}

pub fn sample_diff(root: &Path, config: &Configuration) -> Option<String> {
    let library = library_path(root, config);
    if !library.exists() {
        return None;
    }

    let before = new_for_path(&library, config.format);
    let graph = graph_from_path(
        &library,
        false,
        config.format_options(),
        config.library.frontmatter_document_title.clone(),
    );
    let after = graph.export();

    let mut keys: Vec<&String> = before
        .keys()
        .filter(|key| {
            after
                .get(*key)
                .is_some_and(|normalized| normalized != &before[*key])
        })
        .collect();
    keys.sort();

    let key = keys.first()?;
    let original = &before[*key];
    let normalized = after.get(*key)?;

    let mut output = format!("--- {} (on disk)\n+++ {} (after normalize)\n", key, key);
    for line in line_diff(original, normalized) {
        output.push_str(&line);
        output.push('\n');
    }
    Some(output)
}

fn line_diff(before: &str, after: &str) -> Vec<String> {
    let before_lines: Vec<&str> = before.lines().collect();
    let after_lines: Vec<&str> = after.lines().collect();

    let mut output = Vec::new();
    let mut shown = 0;
    let length = before_lines.len().max(after_lines.len());

    for index in 0..length {
        let original = before_lines.get(index);
        let normalized = after_lines.get(index);
        if original == normalized {
            continue;
        }
        if shown >= 12 {
            output.push("… diff truncated".to_string());
            break;
        }
        if let Some(line) = original {
            output.push(format!("-{}", line));
        }
        if let Some(line) = normalized {
            output.push(format!("+{}", line));
        }
        shown += 1;
    }

    output
}