lazin 1.0.3

Primarily a dotfiles manager
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
145
146

use std::{
    cell::RefCell,
    path::{Path, PathBuf},
};

use lazin_error::{Context, LazinResult};
use lazin_gpg_wrapper::{DecryptOptions, EncryptOptions};

use crate::cache::{Cache, Entry, FileHash};

pub mod gitignore;

pub const GPG_EXTENSION: &str = "gpg";

// TODO: Add a flag for skipping trying to decrypt or continue linking if
// decryption fails
#[derive(Debug)]
pub struct EncryptionManager {
    cache: RefCell<Cache>,
}

impl EncryptionManager {
    pub fn new(cache: Cache) -> Self {
        Self {
            cache: RefCell::new(cache),
        }
    }

    pub fn manage_encryption(&self, source: &Path, recipient: &str) -> LazinResult<bool> {
        let file_hash = FileHash::hash(source)?;
        let previous_entry = self
            .cache
            .borrow_mut()
            .add_entry(Entry::Encryption(source.into(), file_hash.clone()))?;

        let file_hash_changed = match previous_entry {
            Some(e) => match e {
                Entry::Encryption(_, old_hash) => file_hash != old_hash,
            },
            None => true,
        };

        let did_encrypt_file = if file_hash_changed || !Self::encrypted_file_exists(source) {
            self.encrypt(source, recipient, None)?;
            true
        } else {
            false
        };

        Ok(did_encrypt_file)
    }

    pub fn manage_decryption(&self, source: &Path, override_output: Option<&Path>) -> LazinResult {
        self.decrypt(source, override_output)?;

        Ok(())
    }

    #[cfg(unix)]
    pub fn can_decrypt(&self, source: &Path) -> LazinResult<bool> {
        let decrypt_to = Path::new("/dev/null");

        if let Err(e) = self.decrypt(source, Some(decrypt_to))
            && let Some(gpg_error) = e.downcast_ref::<lazin_gpg_wrapper::Error>()
        {
            match gpg_error {
                lazin_gpg_wrapper::Error::GpgNotFound => return Ok(false),
                _ => return Err(e),
            };
        }

        Ok(true)
    }

    #[cfg(unix)]
    pub fn can_encrypt(&self, source: &Path, recipient: &str) -> LazinResult<bool> {
        let encrypt_to = PathBuf::from("/dev/null");

        if let Err(e) = self.encrypt(source, recipient, Some(encrypt_to))
            && let Some(gpg_error) = e.downcast_ref::<lazin_gpg_wrapper::Error>()
        {
            match gpg_error {
                lazin_gpg_wrapper::Error::GpgNotFound => return Ok(false),
                _ => return Err(e),
            };
        }

        Ok(true)
    }

    fn decrypt(&self, file: &Path, override_output: Option<&Path>) -> LazinResult<()> {
        let input = Self::get_input_file_with_extension(file);
        let output = override_output.unwrap_or(file);

        lazin_gpg_wrapper::decrypt_file(DecryptOptions {
            input: &input,
            output,
        })
        .with_context(|| {
            format!(
                "EncryptionManager failed to decrypt file: {} into {}",
                input.display(),
                output.display()
            )
        })?;

        Ok(())
    }

    fn encrypt(
        &self,
        file: &Path,
        recipient: &str,
        override_output: Option<PathBuf>,
    ) -> LazinResult<()> {
        let input = file;
        let output = override_output.unwrap_or(Self::get_input_file_with_extension(file));

        lazin_gpg_wrapper::encrypt_file(EncryptOptions {
            input,
            output: &output,
            recipient,
        })
        .with_context(|| {
            format!(
                "EncryptionManager failed to encrypt file: {} into {}",
                input.display(),
                output.display()
            )
        })?;

        Ok(())
    }

    pub fn get_input_file_with_extension(file: &Path) -> PathBuf {
        file.with_added_extension(GPG_EXTENSION)
    }

    pub fn flush_cache(&self) -> LazinResult {
        self.cache.borrow().save()
    }

    fn encrypted_file_exists(file: &Path) -> bool {
        Self::get_input_file_with_extension(file).exists()
    }
}