tidalcycles-rs 0.1.4

supercollider, superdirt, and tidalcycles with rust.
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use std::cmp::Ordering;
use std::env;
use std::fs;

pub fn find_gh() -> Option<std::path::PathBuf> {
    if let Ok(path) = which::which("gh") {
        Some(path)
    } else if std::path::Path::new(r"C:\Program Files\GitHub CLI\gh.exe").exists() {
        Some(std::path::PathBuf::from(
            r"C:\Program Files\GitHub CLI\gh.exe",
        ))
    } else {
        None
    }
}

pub fn find_ghci() -> Option<std::path::PathBuf> {
    if let Ok(path) = which::which("ghci") {
        Some(path)
    } else if std::path::Path::new(r"C:\ghcup\bin\ghci.exe").exists() {
        Some(std::path::PathBuf::from(r"C:\ghcup\bin\ghci.exe"))
    } else {
        None
    }
}

pub fn find_supercollider() -> Option<std::path::PathBuf> {
    // Try to find sclang in PATH
    if let Ok(path) = which::which("sclang") {
        return Some(path);
    }

    // Try to find the latest SuperCollider in Program Files
    let program_files =
        std::env::var("ProgramFiles").unwrap_or_else(|_| r"C:\Program Files".to_string());
    let sc_prefix = "SuperCollider-";
    let mut latest_version: Option<(semver::Version, std::path::PathBuf)> = None;

    if let Ok(entries) = fs::read_dir(&program_files) {
        for entry in entries.flatten() {
            let file_name = entry.file_name();
            let file_name = file_name.to_string_lossy();
            if let Some(version_str) = file_name.strip_prefix(sc_prefix) {
                if let Ok(version) = semver::Version::parse(version_str) {
                    let exe_path = entry.path().join("sclang.exe");
                    if exe_path.exists() {
                        match &latest_version {
                            Some((latest, _)) if version.cmp(latest) == Ordering::Greater => {
                                latest_version = Some((version, exe_path));
                            }
                            None => {
                                latest_version = Some((version, exe_path));
                            }
                            _ => {}
                        }
                    }
                }
            }
        }
    }

    latest_version.map(|(_, path)| path)
}

pub fn find_supercollider_scsynth() -> Option<std::path::PathBuf> {
    // Try to find scsynth in PATH
    if let Ok(path) = which::which("scsynth") {
        return Some(path);
    }

    // Try to find the latest SuperCollider scsynth.exe in Program Files
    let program_files =
        std::env::var("ProgramFiles").unwrap_or_else(|_| r"C:\Program Files".to_string());
    let sc_prefix = "SuperCollider-";
    let mut latest_version: Option<(semver::Version, std::path::PathBuf)> = None;

    if let Ok(entries) = fs::read_dir(&program_files) {
        for entry in entries.flatten() {
            let file_name = entry.file_name();
            let file_name = file_name.to_string_lossy();
            if let Some(version_str) = file_name.strip_prefix(sc_prefix) {
                if let Ok(version) = semver::Version::parse(version_str) {
                    let exe_path = entry.path().join("scsynth.exe");
                    if exe_path.exists() {
                        match &latest_version {
                            Some((latest, _)) if version.cmp(latest) == Ordering::Greater => {
                                latest_version = Some((version, exe_path));
                            }
                            None => {
                                latest_version = Some((version, exe_path));
                            }
                            _ => {}
                        }
                    }
                }
            }
        }
    }

    latest_version.map(|(_, path)| path)
}

pub fn find_ghcup() -> Option<std::path::PathBuf> {
    if let Ok(path) = which::which("ghcup") {
        Some(path)
    } else if std::path::Path::new(r"C:\ghcup\bin\ghcup.exe").exists() {
        Some(std::path::PathBuf::from(r"C:\ghcup\bin\ghcup.exe"))
    } else {
        None
    }
}

pub fn find_cabal() -> Option<std::path::PathBuf> {
    if let Ok(path) = which::which("cabal") {
        Some(path)
    } else if std::path::Path::new(r"C:\ghcup\bin\cabal.exe").exists() {
        Some(std::path::PathBuf::from(r"C:\ghcup\bin\cabal.exe"))
    } else {
        None
    }
}

pub fn find_tools_set_env_path() {
    if let Some(sc_path) = find_supercollider() {
        if let Some(sc_dir) = sc_path.parent() {
            let path_var = env::var_os("PATH").unwrap_or_default();
            let paths_vec: Vec<std::path::PathBuf> = env::split_paths(&path_var).collect();
            let sc_dir_str = sc_dir.to_string_lossy().to_lowercase();

            let already_in_path = paths_vec
                .iter()
                .any(|p| p.to_string_lossy().to_lowercase() == sc_dir_str);

            if !already_in_path {
                let mut new_paths: Vec<std::path::PathBuf> = vec![sc_dir.to_path_buf()];
                new_paths.extend(paths_vec);
                let new_path = env::join_paths(new_paths).expect("Failed to join PATH");
                unsafe {
                    env::set_var("PATH", &new_path);
                }
            }
        }
    }
}