depon 0.1.1

Execute subsequent command only if given dependencies changed
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

use std::{collections::HashMap, fs::File, io::Write, path::Path, time::SystemTime};

use clap::Parser;
use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};

#[derive(Parser)]
struct Cli {
    observe: Vec<String>,
}

type DeponState = HashMap<String, u64>;

enum ExitCode {
    Do = 0isize,
    DoNot = 1isize,
}

fn main() {
    let args = Cli::parse();

    if args.observe.iter().count() == 0 {
        println!("No files to watch");
        std::process::exit(ExitCode::Do as i32);
    }

    let last_state = read_state();

    let current_state: DeponState = args
        .observe
        .par_iter()
        .map(|file_path| {
            let modified_at = when_modified(&file_path);
            return (file_path.to_string(), modified_at);
        })
        .collect();

    let decision: ExitCode;
    if last_state.is_some() {
        if compare_state(current_state.clone(), last_state.unwrap()) {
            decision = ExitCode::Do;
        } else {
            decision = ExitCode::DoNot;
        }
    } else {
        decision = ExitCode::Do;
    }

    match decision {
        ExitCode::Do => {
            println!("Executing command");
            write_state(current_state.clone());
            std::process::exit(ExitCode::Do as i32);
        }
        ExitCode::DoNot => {
            println!("Skipping command");
            std::process::exit(ExitCode::DoNot as i32);
        }
    }
}

fn read_state() -> Option<DeponState> {
    const LOCK_FILE_PATH: &str = "./depon.lock";
    if Path::new(LOCK_FILE_PATH).exists() {
        let lock_file = File::open(LOCK_FILE_PATH);
        if lock_file.is_ok() {
            return Some(serde_yaml::from_reader(lock_file.unwrap()).unwrap());
        }
    }
    return None;
}

fn write_state(state: DeponState) {
    let yaml = serde_yaml::to_string(&state).expect("Unable to serialize state");

    const LOCK_FILE_PATH: &str = "./depon.lock";
    if Path::new(LOCK_FILE_PATH).exists() {
        std::fs::remove_file(LOCK_FILE_PATH).expect("Unable to remove file");
    }

    File::create(LOCK_FILE_PATH)
        .expect("Unable to create file")
        .write_all(yaml.as_bytes())
        .expect("Unable to write data");
}

fn when_modified(file_path: &String) -> u64 {
    let metadata = std::fs::metadata(&file_path)
        .expect(format!("Unable to read metadata of {}", file_path).as_str());

    let last_modified = metadata.modified().expect("modified time not available");
    return last_modified
        .duration_since(SystemTime::UNIX_EPOCH)
        .expect("Time went backwards")
        .as_secs();
}

fn compare_state(current_state: DeponState, last_state: DeponState) -> bool {
    if last_state.keys().count() != current_state.keys().count() {
        return true;
    }

    let result = current_state.iter().find(|f| {
        let current_file_path = f.0;
        let current_modified_at = f.1;
        let last_modified_at = last_state.get(current_file_path);
        if last_modified_at.is_some() {
            return last_modified_at.unwrap() != current_modified_at;
        }
        return true;
    });
    return result.is_some();
}