1mod activate;
2mod env;
3mod package;
4mod store;
5mod term;
6
7use slox_cli::{Commands, EnvCommand, PkgCommand};
8use store::StorePaths;
9use term::{Progress, Report};
10
11pub fn report_error(error: &str) {
12 term::report_error(error);
13}
14
15pub fn run(command: Commands) -> Result<(), String> {
16 run_with_store(command, &StorePaths::default())
17}
18
19fn run_with_store(command: Commands, store: &StorePaths) -> Result<(), String> {
20 match command {
21 Commands::Env { command } => {
22 let progress = Progress::start("updating environment");
23 match handle_env(store, command) {
24 Ok(report) => {
25 progress.finish(report);
26 Ok(())
27 }
28 Err(error) => {
29 progress.fail();
30 Err(error)
31 }
32 }
33 }
34 Commands::Activate { command } => {
35 println!("{}", activate::activation_script(store, command)?);
36 Ok(())
37 }
38 Commands::Pkg { command } => {
39 let progress = Progress::start("processing package");
40 match handle_pkg(store, command) {
41 Ok(report) => {
42 progress.finish(report);
43 Ok(())
44 }
45 Err(error) => {
46 progress.fail();
47 Err(error)
48 }
49 }
50 }
51 }
52}
53
54fn handle_env(store: &StorePaths, cmd: EnvCommand) -> Result<Report, String> {
55 match cmd {
56 EnvCommand::Add { path } => {
57 let env_dir = env::add_env(store, &path)?;
58 Ok(Report::new(format!("added env `{path}`"))
59 .detail(format!("path: {}", env_dir.display()))
60 .detail(format!("bin: {}", store.env_bin_dir(&path).display()))
61 .detail(format!("shims: {}", store.shim_bin_dir().display())))
62 }
63 EnvCommand::Remove { path } => {
64 let result = env::remove_env(store, &path)?;
65 let summary = if result.removed {
66 format!("removed env `{path}`")
67 } else {
68 format!("env `{path}` was already absent")
69 };
70 let mut report =
71 Report::new(summary).detail(format!("path: {}", result.env_dir.display()));
72 if result.cleared_active {
73 report = report.detail("active env cleared; shims now point to root/bin");
74 }
75 Ok(report)
76 }
77 EnvCommand::Set { path } => {
78 let active_bin = env::set_env(store, &path)?;
79 Ok(Report::new(format!("activated env `{path}`"))
80 .detail(format!("bin: {}", active_bin.display()))
81 .detail(format!("shims: {}", store.shim_bin_dir().display())))
82 }
83 }
84}
85
86fn handle_pkg(store: &StorePaths, cmd: PkgCommand) -> Result<Report, String> {
87 match cmd {
88 PkgCommand::Add { path } => {
89 let install = package::download(store, &package::parse_pkg(&path)?)?;
90 Ok(
91 Report::new(format!("added package `{}`", install.package_name))
92 .detail(format!("binary: {}", install.installed_binary.display()))
93 .detail(format!("shim: {}", install.shim_binary.display())),
94 )
95 }
96 PkgCommand::Remove { path } => {
97 let removed = package::remove(store, &path)?;
98 let summary = if removed.removed {
99 format!("removed package `{}`", removed.package_name)
100 } else {
101 format!("package `{}` was not installed", removed.package_name)
102 };
103 Ok(Report::new(summary)
104 .detail(format!("binary: {}", removed.removed_binary.display()))
105 .detail(format!("shim: {}", removed.shim_binary.display())))
106 }
107 }
108}
109
110#[cfg(test)]
111mod tests {
112 use super::{
113 activate::activation_script,
114 env::{active_bin_dir, active_env_name, add_env, remove_env, set_env},
115 package::{Pkg, install_built_binary, parse_pkg, remove as remove_pkg, run_build_script},
116 store::StorePaths,
117 };
118 use crate::activate;
119 use slox_cli::ActivateCommand;
120 use std::fs;
121 use std::path::PathBuf;
122 use std::time::{SystemTime, UNIX_EPOCH};
123
124 fn make_temp_dir(name: &str) -> PathBuf {
125 let unique = SystemTime::now()
126 .duration_since(UNIX_EPOCH)
127 .expect("time went backwards")
128 .as_nanos();
129 let dir = std::env::temp_dir().join(format!("slox-{name}-{unique}"));
130 fs::create_dir_all(&dir).expect("failed to create temp dir");
131 dir
132 }
133
134 fn make_store() -> StorePaths {
135 StorePaths {
136 base: make_temp_dir("store"),
137 }
138 }
139
140 #[test]
141 fn parse_github_package() {
142 let pkg = parse_pkg("devwon/slox@github").expect("github package should parse");
143 match pkg {
144 Pkg::GitHub { user, repo } => {
145 assert_eq!(user, "devwon");
146 assert_eq!(repo, "slox");
147 }
148 Pkg::Regit { .. } => panic!("expected github package"),
149 }
150 }
151
152 #[test]
153 fn parse_regit_package() {
154 let pkg = parse_pkg("plur@sloxpkgs").expect("sloxpkgs package should parse");
155 match pkg {
156 Pkg::Regit { pkg } => assert_eq!(pkg, "plur"),
157 Pkg::GitHub { .. } => panic!("expected sloxpkgs package"),
158 }
159 }
160
161 #[test]
162 fn reject_invalid_package_format() {
163 let error = parse_pkg("invalid-package").expect_err("package parse should fail");
164 assert!(error.contains("user/repo@github"));
165 }
166
167 #[test]
168 fn activation_script_uses_root_bin_path() {
169 let store = StorePaths {
170 base: PathBuf::from("/tmp/slox-store"),
171 };
172
173 let script = activation_script(&store, ActivateCommand::Zsh)
174 .expect("root activation script should render");
175 assert_eq!(
176 script,
177 concat!(
178 "_slox_store='/tmp/slox-store'\n",
179 "_slox_bin='/tmp/slox-store/bin'\n",
180 "_slox_filtered_path=\n",
181 "_slox_old_ifs=$IFS\n",
182 "IFS=:\n",
183 "for _slox_entry in $PATH; do\n",
184 " case \"$_slox_entry\" in\n",
185 " \"$_slox_store\"/bin|\"$_slox_store\"/bin/)\n",
186 " ;;\n",
187 " '')\n",
188 " ;;\n",
189 " *)\n",
190 " if [ -n \"$_slox_filtered_path\" ]; then\n",
191 " _slox_filtered_path=\"$_slox_filtered_path:$_slox_entry\"\n",
192 " else\n",
193 " _slox_filtered_path=\"$_slox_entry\"\n",
194 " fi\n",
195 " ;;\n",
196 " esac\n",
197 "done\n",
198 "IFS=$_slox_old_ifs\n",
199 "if [ -n \"$_slox_filtered_path\" ]; then\n",
200 " export PATH=\"$_slox_bin:$_slox_filtered_path\"\n",
201 "else\n",
202 " export PATH=\"$_slox_bin\"\n",
203 "fi\n",
204 "unset _slox_store _slox_bin _slox_filtered_path _slox_old_ifs _slox_entry"
205 )
206 );
207 }
208
209 #[test]
210 fn add_and_remove_env_under_store() {
211 let store = make_store();
212 let env_dir = store.env_dir("demo");
213
214 add_env(&store, "demo").expect("env should be created");
215 assert!(env_dir.is_dir());
216 assert!(store.env_bin_dir("demo").is_dir());
217
218 remove_env(&store, "demo").expect("env should be removed");
219 assert!(!env_dir.exists());
220
221 fs::remove_dir_all(store.base).expect("failed to clean store dir");
222 }
223
224 #[test]
225 fn set_env_changes_active_bin_dir_and_activation_script() {
226 let store = make_store();
227 add_env(&store, "demo").expect("env should be created");
228
229 set_env(&store, "demo").expect("env should be set");
230 assert_eq!(
231 active_env_name(&store).expect("active env should be readable"),
232 Some("demo".to_string())
233 );
234 assert_eq!(
235 active_bin_dir(&store).expect("active bin dir should resolve"),
236 store.env_bin_dir("demo")
237 );
238
239 let script = activation_script(&store, ActivateCommand::Bash)
240 .expect("env activation script should render");
241 assert_eq!(
242 script,
243 format!(
244 concat!(
245 "_slox_store={store}\n",
246 "_slox_bin={bin}\n",
247 "_slox_filtered_path=\n",
248 "_slox_old_ifs=$IFS\n",
249 "IFS=:\n",
250 "for _slox_entry in $PATH; do\n",
251 " case \"$_slox_entry\" in\n",
252 " \"$_slox_store\"/bin|\"$_slox_store\"/bin/)\n",
253 " ;;\n",
254 " '')\n",
255 " ;;\n",
256 " *)\n",
257 " if [ -n \"$_slox_filtered_path\" ]; then\n",
258 " _slox_filtered_path=\"$_slox_filtered_path:$_slox_entry\"\n",
259 " else\n",
260 " _slox_filtered_path=\"$_slox_entry\"\n",
261 " fi\n",
262 " ;;\n",
263 " esac\n",
264 "done\n",
265 "IFS=$_slox_old_ifs\n",
266 "if [ -n \"$_slox_filtered_path\" ]; then\n",
267 " export PATH=\"$_slox_bin:$_slox_filtered_path\"\n",
268 "else\n",
269 " export PATH=\"$_slox_bin\"\n",
270 "fi\n",
271 "unset _slox_store _slox_bin _slox_filtered_path _slox_old_ifs _slox_entry"
272 ),
273 store = activate::shell_single_quote(&store.base.display().to_string()),
274 bin = activate::shell_single_quote(&store.shim_bin_dir().display().to_string())
275 )
276 );
277
278 fs::remove_dir_all(store.base).expect("failed to clean store dir");
279 }
280
281 #[test]
282 fn removing_active_env_clears_active_env_file() {
283 let store = make_store();
284 add_env(&store, "demo").expect("env should be created");
285 set_env(&store, "demo").expect("env should be set");
286
287 remove_env(&store, "demo").expect("env should be removed");
288 assert_eq!(
289 active_env_name(&store).expect("active env should be readable"),
290 None
291 );
292 assert_eq!(
293 active_bin_dir(&store).expect("root bin should be used"),
294 store.root_bin_dir()
295 );
296
297 fs::remove_dir_all(store.base).expect("failed to clean store dir");
298 }
299
300 #[test]
301 fn build_and_install_github_package_layout() {
302 let repo_name = "demo";
303 let repo_dir = make_temp_dir("repo");
304 let root_bin_dir = make_temp_dir("root-bin");
305
306 fs::write(
307 repo_dir.join("build"),
308 format!(
309 "#!/bin/sh\nmkdir -p bin\nprintf '#!/bin/sh\\necho installed\\n' > bin/{repo_name}\nchmod +x bin/{repo_name}\n"
310 ),
311 )
312 .expect("failed to write build script");
313
314 run_build_script(&repo_dir).expect("build script should succeed");
315 let installed_binary = install_built_binary(&repo_dir, repo_name, &root_bin_dir)
316 .expect("install should succeed");
317
318 assert!(installed_binary.is_file());
319 let contents =
320 fs::read_to_string(installed_binary).expect("failed to read installed binary");
321 assert!(contents.contains("installed"));
322
323 fs::remove_dir_all(repo_dir).expect("failed to clean repo dir");
324 fs::remove_dir_all(root_bin_dir).expect("failed to clean root bin dir");
325 }
326
327 #[test]
328 fn install_target_follows_active_env_bin() {
329 let store = make_store();
330 let repo_name = "demo";
331 let repo_dir = make_temp_dir("repo");
332
333 add_env(&store, "demo-env").expect("env should be created");
334 set_env(&store, "demo-env").expect("env should be set");
335
336 fs::write(
337 repo_dir.join("build"),
338 format!(
339 "#!/bin/sh\nmkdir -p bin\nprintf '#!/bin/sh\\necho active-env\\n' > bin/{repo_name}\nchmod +x bin/{repo_name}\n"
340 ),
341 )
342 .expect("failed to write build script");
343
344 run_build_script(&repo_dir).expect("build script should succeed");
345 let install_dir = active_bin_dir(&store).expect("active bin dir should resolve");
346 let installed_binary = install_built_binary(&repo_dir, repo_name, &install_dir)
347 .expect("install should succeed");
348
349 assert_eq!(
350 installed_binary,
351 store.env_bin_dir("demo-env").join(repo_name)
352 );
353 assert!(installed_binary.is_file());
354
355 fs::remove_dir_all(repo_dir).expect("failed to clean repo dir");
356 fs::remove_dir_all(store.base).expect("failed to clean store dir");
357 }
358
359 #[test]
360 fn sync_active_shims_points_to_active_env_bins() {
361 let store = make_store();
362 add_env(&store, "demo").expect("env should be created");
363
364 fs::create_dir_all(store.env_bin_dir("demo")).expect("env bin dir should exist");
365 fs::write(
366 store.env_bin_dir("demo").join("demo"),
367 "#!/bin/sh\necho env\n",
368 )
369 .expect("binary should be written");
370
371 set_env(&store, "demo").expect("env should be set");
372
373 let shim_path = store.shim_bin_dir().join("demo");
374 assert!(shim_path.is_file());
375 let shim_contents = fs::read_to_string(&shim_path).expect("shim should be readable");
376 assert!(
377 shim_contents.contains(&store.env_bin_dir("demo").join("demo").display().to_string())
378 );
379
380 fs::remove_dir_all(store.base).expect("failed to clean store dir");
381 }
382
383 #[test]
384 fn clearing_active_env_refreshes_shims_to_root_bin() {
385 let store = make_store();
386 add_env(&store, "demo").expect("env should be created");
387 fs::create_dir_all(store.root_bin_dir()).expect("root bin dir should exist");
388 fs::write(
389 store.root_bin_dir().join("root-tool"),
390 "#!/bin/sh\necho root\n",
391 )
392 .expect("root binary should be written");
393 fs::write(
394 store.env_bin_dir("demo").join("env-tool"),
395 "#!/bin/sh\necho env\n",
396 )
397 .expect("env binary should be written");
398
399 set_env(&store, "demo").expect("env should be set");
400 remove_env(&store, "demo").expect("env should be removed");
401
402 let shim_dir = store.shim_bin_dir();
403 assert!(shim_dir.join("root-tool").is_file());
404 assert!(!shim_dir.join("env-tool").exists());
405
406 fs::remove_dir_all(store.base).expect("failed to clean store dir");
407 }
408
409 #[test]
410 fn remove_package_deletes_binary_and_refreshes_shim() {
411 let store = make_store();
412 fs::create_dir_all(store.root_bin_dir()).expect("root bin dir should exist");
413 fs::write(store.root_bin_dir().join("demo"), "#!/bin/sh\necho root\n")
414 .expect("package binary should be written");
415 super::env::sync_active_shims(&store).expect("shims should be created");
416
417 let removed = remove_pkg(&store, "demo").expect("package should be removable");
418
419 assert!(removed.removed);
420 assert!(!store.root_bin_dir().join("demo").exists());
421 assert!(!store.shim_bin_dir().join("demo").exists());
422
423 fs::remove_dir_all(store.base).expect("failed to clean store dir");
424 }
425}