alf_tui 0.5.0

A smolderingly-nimble Rust TUI to rediscover your custom shell.
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

//! Shared helpers for tests that need an isolated `$HOME`.

use std::env::{remove_var, set_var, var, var_os};
use std::ffi::{OsStr, OsString};
use std::fs;
use std::path::PathBuf;
use std::sync::{Mutex, MutexGuard};
use tempfile::TempDir;

static ENV_MUTEX: Mutex<()> = Mutex::new(());

/// A temporary `$HOME` directory that is restored when dropped
///
/// Environment mutation is serialized through a shared mutex, so tests that swap `$HOME` cannot
/// race one another when the suite runs on threads instead of processes.
pub struct TempHome {
   _guard: MutexGuard<'static, ()>,
   dir: TempDir,
   old_home: Option<String>,
   overrides: Vec<(String, Option<OsString>)>,
}

impl TempHome {
   /// Create a temporary directory and point `$HOME` at it
   pub fn new() -> Self {
      let guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
      let temp_dir = TempDir::new().expect("Should create temp dir");
      let old_home = var("HOME").ok();
      set_var("HOME", temp_dir.path());
      Self {
         _guard: guard,
         dir: temp_dir,
         old_home,
         overrides: Vec::new(),
      }
   }

   /// Absolute path of `name` inside the temporary home, as a string
   pub fn absolute(
      &self,
      name: &str,
   ) -> String {
      self.path().join(name).to_string_lossy().to_string()
   }

   /// Path of the temporary home
   pub fn path(&self) -> PathBuf {
      self.dir.path().to_path_buf()
   }

   /// Override an environment variable until this temporary home is dropped
   ///
   /// The original value is restored on drop, so a test can point home resolution at an empty or
   /// deliberately malformed value without leaking it into the rest of the suite.
   pub fn set_env(
      &mut self,
      key: &str,
      value: impl AsRef<OsStr>,
   ) {
      self.remember(key);
      set_var(key, value);
   }

   /// Create an empty file named `name` inside the temporary home
   pub fn touch(
      &self,
      name: &str,
   ) {
      fs::File::create(self.path().join(name)).expect("Should create file");
   }

   /// Remove an environment variable until this temporary home is dropped
   pub fn unset_env(
      &mut self,
      key: &str,
   ) {
      self.remember(key);
      remove_var(key);
   }

   /// Record the current value of `key` the first time it is overridden, so `Drop` can put it back
   fn remember(
      &mut self,
      key: &str,
   ) {
      if !self.overrides.iter().any(|(name, _)| name == key) {
         self.overrides.push((key.to_string(), var_os(key)));
      }
   }
}

impl Default for TempHome {
   fn default() -> Self {
      Self::new()
   }
}

impl Drop for TempHome {
   fn drop(&mut self) {
      for (key, value) in self.overrides.drain(..) {
         match value {
            Some(value) => set_var(&key, value),
            None => remove_var(&key),
         }
      }

      match &self.old_home {
         Some(home) => set_var("HOME", home),
         None => remove_var("HOME"),
      }
   }
}