Skip to main content

clm_rust_core/
fs_utils.rs

1use std::fs;
2use std::path::{Path, PathBuf};
3use std::io::{self, Read};
4
5// Explicit SHA-256 computation for legacy/specific SHA-256 contracts.
6pub fn compute_sha256_hex(content: &[u8]) -> String {
7    use sha2::{Digest, Sha256};
8    let mut hasher = Sha256::new();
9    hasher.update(content);
10    format!("{:x}", hasher.finalize())
11}
12
13pub fn compute_content_hash(input: &str) -> String {
14    if input == "-" {
15        let mut buffer = Vec::new();
16        let mut stdin = io::stdin();
17        let _ = stdin.read_to_end(&mut buffer);
18        crate::hash::raw_hash_bytes(&buffer)
19    } else if let Ok(metadata) = fs::metadata(input) {
20        if metadata.is_file() {
21            if let Ok(data) = fs::read(input) {
22                return crate::hash::raw_hash_bytes(&data);
23            }
24        }
25        crate::hash::raw_hash_bytes(input.as_bytes())
26    } else {
27        crate::hash::raw_hash_bytes(input.as_bytes())
28    }
29}
30
31pub fn compute_stripped_file_hash(path: &Path) -> io::Result<String> {
32    let content = fs::read_to_string(path)?;
33    // Emulate bash's $(cat file) which strips trailing newlines (\n and \r)
34    let trimmed = content.trim_end_matches(|c| c == '\n' || c == '\r');
35    Ok(crate::hash::raw_hash_bytes(trimmed.as_bytes()))
36}
37
38pub fn get_file_handle(raw_path: &str, clm_root: Option<&str>) -> String {
39    // 1. Resolve absolute path
40    let path = Path::new(raw_path);
41    let abs_path = if path.is_absolute() {
42        path.to_path_buf()
43    } else if let Ok(curr) = std::env::current_dir() {
44        curr.join(path)
45    } else {
46        path.to_path_buf()
47    };
48
49    // 2. Canonicalize path representation (resolve parent dirs/dots, but keep as String)
50    // We do clean normalization manually to avoid issues with non-existent paths.
51    let mut components = Vec::new();
52    for component in abs_path.components() {
53        match component {
54            std::path::Component::Prefix(prefix) => {
55                // Windows prefix (e.g. C:) -> map to lowercase /c/
56                let prefix_str = prefix.as_os_str().to_string_lossy().to_string();
57                if prefix_str.len() >= 2 && prefix_str.ends_with(':') {
58                    let drive = prefix_str[0..1].to_lowercase();
59                    components.push(format!("/{}", drive));
60                } else {
61                    components.push(prefix_str);
62                }
63            }
64            std::path::Component::RootDir => {
65                // Root is implicit if components start with /
66            }
67            std::path::Component::CurDir => {}
68            std::path::Component::ParentDir => {
69                components.pop();
70            }
71            std::path::Component::Normal(val) => {
72                components.push(val.to_string_lossy().to_string());
73            }
74        }
75    }
76
77    let mut norm_abs = components.join("/");
78    if !norm_abs.starts_with('/') {
79        norm_abs = format!("/{}", norm_abs);
80    }
81    // Remove duplicate slashes
82    while norm_abs.contains("//") {
83        norm_abs = norm_abs.replace("//", "/");
84    }
85    if norm_abs.len() > 1 && norm_abs.ends_with('/') {
86        norm_abs.pop();
87    }
88
89    // Normalize CLM_ROOT
90    let root_path = clm_root.map(PathBuf::from).unwrap_or_else(|| {
91        std::env::var("CLM_ROOT")
92            .map(PathBuf::from)
93            .unwrap_or_else(|_| PathBuf::from("."))
94    });
95    
96    let abs_root = if root_path.is_absolute() {
97        root_path
98    } else if let Ok(curr) = std::env::current_dir() {
99        curr.join(root_path)
100    } else {
101        root_path
102    };
103
104    let mut root_components = Vec::new();
105    for component in abs_root.components() {
106        match component {
107            std::path::Component::Prefix(prefix) => {
108                let prefix_str = prefix.as_os_str().to_string_lossy().to_string();
109                if prefix_str.len() >= 2 && prefix_str.ends_with(':') {
110                    let drive = prefix_str[0..1].to_lowercase();
111                    root_components.push(format!("/{}", drive));
112                } else {
113                    root_components.push(prefix_str);
114                }
115            }
116            std::path::Component::RootDir => {}
117            std::path::Component::CurDir => {}
118            std::path::Component::ParentDir => {
119                root_components.pop();
120            }
121            std::path::Component::Normal(val) => {
122                root_components.push(val.to_string_lossy().to_string());
123            }
124        }
125    }
126    let mut norm_root = root_components.join("/");
127    if !norm_root.starts_with('/') {
128        norm_root = format!("/{}", norm_root);
129    }
130    while norm_root.contains("//") {
131        norm_root = norm_root.replace("//", "/");
132    }
133    if norm_root.len() > 1 && norm_root.ends_with('/') {
134        norm_root.pop();
135    }
136
137    // Check if norm_abs is under norm_root
138    let rel_path = if norm_abs == norm_root {
139        ".".to_string()
140    } else if norm_abs.starts_with(&format!("{}/", norm_root)) {
141        norm_abs[norm_root.len() + 1..].to_string()
142    } else {
143        // Fallback to filename
144        path.file_name()
145            .map(|f| f.to_string_lossy().to_string())
146            .unwrap_or_else(|| "".to_string())
147    };
148
149    format!("file:{}", rel_path)
150}
151
152pub fn compute_g_time() -> String {
153    let now = chrono::Local::now();
154    let ts = now.format("%Y-%m-%dT%H:%M:%S%z").to_string();
155    let tz_name = if let Ok(link) = std::fs::read_link("/etc/localtime") {
156        if let Some(pos) = link.to_string_lossy().find("/zoneinfo/") {
157            link.to_string_lossy()[pos + 10..].to_string()
158        } else {
159            now.format("%Z").to_string()
160        }
161    } else {
162        now.format("%Z").to_string()
163    };
164    format!("sha256|{}|{}", ts, tz_name)
165}
166
167pub fn get_clm_root() -> PathBuf {
168    let raw = std::env::var("CLM_ROOT").unwrap_or_else(|_| ".".into());
169    normalize_windows_path(Path::new(&raw))
170}
171
172pub fn get_data_dir(clm_root: &str, pillar: &str) -> PathBuf {
173    let zero_fs = crate::utils::is_zero_fs();
174    if zero_fs {
175        let tmp = std::env::var("TMPDIR").unwrap_or_else(|_| std::env::temp_dir().to_string_lossy().to_string());
176        PathBuf::from(tmp).join("data").join(pillar)
177    } else {
178        Path::new(clm_root).join("data").join(pillar)
179    }
180}
181
182#[cfg(test)]
183mod tests {
184    use super::*;
185
186    #[test]
187    fn test_sha256() {
188        assert_eq!(
189            compute_sha256_hex(b"hello"),
190            "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
191        );
192    }
193}
194
195pub fn get_bash_command() -> String {
196    if cfg!(target_os = "windows") {
197        if let Ok(bash_env) = std::env::var("BASH") {
198            if Path::new(&bash_env).exists() {
199                return bash_env;
200            }
201        }
202        let git_bash = "C:\\Program Files\\Git\\bin\\bash.exe";
203        if Path::new(git_bash).exists() {
204            return git_bash.to_string();
205        }
206    }
207    "bash".to_string()
208}
209
210pub fn normalize_windows_path(p: &Path) -> PathBuf {
211    if cfg!(target_os = "windows") {
212        let s = p.to_string_lossy().to_string();
213        if s.starts_with('/') && s.len() >= 3 && s.chars().nth(2) == Some('/') {
214            let drive = s.chars().nth(1).unwrap().to_uppercase().to_string();
215            let rest = &s[2..];
216            return PathBuf::from(format!("{}:{}", drive, rest));
217        } else if s.starts_with('/') && s.len() == 2 {
218            let drive = s.chars().nth(1).unwrap().to_uppercase().to_string();
219            return PathBuf::from(format!("{}:\\", drive));
220        }
221    }
222    p.to_path_buf()
223}