monoripple 0.0.1

Symbol-aware affected target detection for JavaScript and TypeScript monorepos
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

use std::collections::BTreeSet;
use std::path::{Path, PathBuf};
use std::process::Command;

use anyhow::{Context, Result, bail};

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ChangeKind {
    Added,
    Modified,
    Deleted,
    Renamed { old_path: PathBuf },
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ChangedFile {
    pub path: PathBuf,
    pub kind: ChangeKind,
}

pub fn changed_files(root: &Path, base: &str) -> Result<Vec<ChangedFile>> {
    let output = git(root, &["diff", "--name-status", "--find-renames", base])?;
    let mut changes = Vec::new();
    let mut known = BTreeSet::new();

    for line in output.lines() {
        let fields: Vec<_> = line.split('\t').collect();
        let Some(status) = fields.first() else {
            continue;
        };

        let change = match status.chars().next() {
            Some('A') if fields.len() >= 2 => ChangedFile {
                path: root.join(fields[1]),
                kind: ChangeKind::Added,
            },
            Some('M' | 'T') if fields.len() >= 2 => ChangedFile {
                path: root.join(fields[1]),
                kind: ChangeKind::Modified,
            },
            Some('D') if fields.len() >= 2 => ChangedFile {
                path: root.join(fields[1]),
                kind: ChangeKind::Deleted,
            },
            Some('R') if fields.len() >= 3 => ChangedFile {
                path: root.join(fields[2]),
                kind: ChangeKind::Renamed {
                    old_path: PathBuf::from(fields[1]),
                },
            },
            _ => continue,
        };
        known.insert(change.path.clone());
        changes.push(change);
    }

    let untracked = git(root, &["ls-files", "--others", "--exclude-standard"])?;
    for path in untracked.lines().filter(|path| !path.is_empty()) {
        let path = root.join(path);
        if known.insert(path.clone()) {
            changes.push(ChangedFile {
                path,
                kind: ChangeKind::Added,
            });
        }
    }

    changes.sort_by(|left, right| left.path.cmp(&right.path));
    Ok(changes)
}

pub fn file_at(root: &Path, revision: &str, path: &Path) -> Result<Option<String>> {
    let relative = path.strip_prefix(root).unwrap_or(path);
    let object = format!("{revision}:{}", relative.to_string_lossy());
    let output = Command::new("git")
        .args(["show", &object])
        .current_dir(root)
        .output()
        .with_context(|| format!("failed to run git show for {}", relative.display()))?;

    if output.status.success() {
        return String::from_utf8(output.stdout)
            .context("git returned non-UTF-8 source")
            .map(Some);
    }

    Ok(None)
}

pub fn repository_root(start: &Path) -> Result<PathBuf> {
    let output = git(start, &["rev-parse", "--show-toplevel"])?;
    Ok(PathBuf::from(output.trim()))
}

fn git(root: &Path, args: &[&str]) -> Result<String> {
    let output = Command::new("git")
        .args(args)
        .current_dir(root)
        .output()
        .with_context(|| format!("failed to run git {}", args.join(" ")))?;

    if !output.status.success() {
        bail!(
            "git {} failed: {}",
            args.join(" "),
            String::from_utf8_lossy(&output.stderr).trim()
        );
    }

    String::from_utf8(output.stdout).context("git returned non-UTF-8 output")
}