cbtr 0.3.0

Check, build, test, run
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use log::debug;
use pathdiff::diff_paths;
use serde::Deserialize;
use std::path::Component;
use std::path::Path;

/// Search from cwd backwards to repo_root
fn back_search(cwd: &Path, repo_root: &Path, file: &str) -> bool {
    let mut current_dir = cwd.to_path_buf();
    loop {
        let candidate = current_dir.join(file);
        if candidate.is_file() {
            debug!("Found {}", candidate.display());
            return true;
        }

        if current_dir == repo_root {
            break;
        }

        current_dir = current_dir.parent().unwrap().to_path_buf();
    }
    false
}

/// Search from repo_root forward to cwd
fn forward_search(cwd: &Path, repo_root: &Path, file: &str) -> bool {
    if let Some(diff) = diff_paths(cwd, repo_root) {
        let mut path = repo_root.to_path_buf();
        let candidate = path.join(file);
        if candidate.is_file() {
            return true;
        }

        for component in diff.components() {
            match component {
                Component::Normal(s) => {
                    path = path.join(s);
                    let candidate = path.join(file);
                    if candidate.is_file() {
                        return true;
                    }
                }
                Component::CurDir => {
                    continue;
                }
                _ => {
                    return false;
                }
            }
        }
    }

    false
}
fn path_search(cwd: &Path, repo_root: &Path, direction: &Direction, file: &str) -> bool {
    match direction {
        Direction::Backwards => back_search(cwd, repo_root, file),
        Direction::Forwards => forward_search(cwd, repo_root, file),
    }
}

#[derive(Deserialize, Debug)]
#[serde(untagged)]
pub enum StringOrVec {
    Single(String),
    Multiple(Vec<String>),
}

impl StringOrVec {
    pub fn to_vec(&self) -> Vec<String> {
        match self {
            StringOrVec::Single(s) => vec![s.clone()],
            StringOrVec::Multiple(v) => v.clone(),
        }
    }
}

#[derive(Debug, Deserialize)]
pub struct Tools {
    pub format: Option<StringOrVec>,
    pub check: Option<StringOrVec>,
    pub build: Option<StringOrVec>,
    pub test: Option<StringOrVec>,
    pub run: Option<StringOrVec>,
}

#[derive(Debug, Deserialize, Default)]
pub enum Direction {
    #[serde(rename = "backwards")]
    Backwards,
    #[default]
    #[serde(rename = "forwards")]
    Forwards,
}

#[derive(Debug, Deserialize)]
pub struct File {
    pub(crate) name: StringOrVec,
    #[serde(rename = "search-direction", default)]
    search_direction: Direction,
}

#[derive(Debug, Deserialize)]
pub struct Entry {
    pub(crate) name: String,
    pub(crate) bin: Option<StringOrVec>,
    pub(crate) file: Option<File>,
    pub(crate) tools: Tools,
}

impl Entry {
    pub fn matches(&self, cwd: &Path, repo_root: &Path) -> bool {
        if let Some(bin) = &self.bin {
            for bin in bin.to_vec() {
                if which::which(&bin).is_err() {
                    debug!("Couldn't find {} on $PATH", bin);
                    return false;
                }
            }
        }

        if let Some(file) = &self.file {
            let direction = &file.search_direction;
            for file in file.name.to_vec() {
                if !path_search(cwd, repo_root, direction, &file) {
                    return false;
                }
            }
        }

        true
    }
}

#[derive(Debug, Deserialize)]
pub struct Config {
    #[serde(rename = "entry")]
    pub(crate) entries: Vec<Entry>,
}

impl Config {
    pub fn append(&mut self, mut other: Config) {
        self.entries.append(&mut other.entries);
    }
}