eck 0.0.4

A fast, simple file & folder encryption manager, written in Rust
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

use crate::{
    diagnostic::{EnkryptitOutput, logging::EnkryptitLogger, output::snippet::Snippet},
    frontend::{
        cli::{
            inspection::inspect_one_or_more_objects,
            params_helpers::{show_params, update_params},
            treatment::treat_objects_with_multiple_paths,
        },
        tui::{input::RealTuiInput, launch_ui},
    },
    types::Version,
};
use clap::{Parser, Subcommand};
mod compression;
mod context;
mod conversions;
mod diagnostic;
mod directory;
mod encryption;
mod errors;
mod frontend;
mod key;
mod metadatas;
mod parallelism;
mod parameters;
mod treatment;
mod types;

use crate::frontend::cli::treatment::treat_object_with_path;

/// The version of `Enkryptit!`
/// Enkryptit versions are separated between :
/// - Nightly versions
/// - Stable versions
///
/// This constant is only for `Nightly` version.
///
/// So, for example, if you download **Enkryptit!** v0.1.4, it is the 4th nightly version of 1st stable version.
pub const VERSION: Version = 4;

#[derive(Parser)]
#[command(name = "eck")]
#[command(author = "Olruix")]
#[command(version = "0.0.3")]
#[command(about = "Fast & Secure File Encryption Manager")]
/// The `Cli` structure for **Enkryptit!** cli-tool
/// \
/// Contains :
/// \
/// - The command
/// - The path (for encrypting/decrypting a file or folder)
/// - The password (for encrypting/decrypting a file or folder w/ password)
struct Cli {
    #[command(subcommand)]
    command: Option<Commands>,

    /// Chemin(s) vers le fichier ou dossier
    #[arg(value_name = "PATH")]
    path: Vec<String>,

    /// Mot de passe (optionnel)
    #[arg(short = 'p', long = "password")]
    password: Option<String>,
}

#[derive(Subcommand)]
/// All the commands available :
/// Ui --> open the UI
/// Inspect --> Inspect one / many files
/// Params / Parameters
/// |-> no arg : show current parameters
/// |-> compression + <ALGO> : change compression algorithm
/// |-> key type + <KEY_TYPE> : change key type
enum Commands {
    Ui,
    Inspect {
        #[arg(value_name = "PATHS")]
        paths: Vec<String>,
    },
    Params {
        /// Change compression algorithm
        #[arg(short = 'c', long = "compression", value_name = "ALGO")]
        compression: Option<String>,

        /// Change key type
        #[arg(short = 'k', long = "keytype", value_name = "TYPE")]
        key_type: Option<String>,

        /// Change parallelism type
        #[arg(short = 'p', long = "parallelism", value_name = "PARA")]
        parallelism: Option<String>,
    },
    Parameters {
        #[arg(short = 'c', long = "compression", value_name = "ALGO")]
        compression: Option<String>,

        #[arg(long = "keytype", visible_alias = "kt", value_name = "TYPE")]
        key_type: Option<String>,

        /// Change parallelism type
        #[arg(short = 'p', long = "parallelism", value_name = "PARA")]
        parallelism: Option<String>,
    },
}

fn main() {
    let cli: Cli = Cli::parse();

    if let Err(e) = EnkryptitLogger::init() {
        EnkryptitOutput::error("Error while initializing the logger.", e)
            .with_location("main.rs::main()")
            .display();
    }

    match cli.command {
        Some(Commands::Ui) => {
            // If the command is `Ui`, we launch the ui.
            launch_ui(&RealTuiInput);
        }
        Some(Commands::Params {
            compression,
            key_type,
            parallelism,
        }) => {
            if compression.is_none() && key_type.is_none() && parallelism.is_none() {
                // If we don't have any arg, we show the current parameters
                show_params()
            } else {
                // Else, we update the parameters
                update_params(compression, key_type, parallelism);
            }
        }
        Some(Commands::Inspect { paths }) => {
            inspect_one_or_more_objects(&paths);
        }
        Some(Commands::Parameters {
            compression,
            key_type,
            parallelism,
        }) => {
            // Same we `Parameters`
            if compression.is_none() && key_type.is_none() && parallelism.is_none() {
                show_params()
            } else {
                update_params(compression, key_type, parallelism);
            }
        }
        None => {
            let path: Vec<String> = cli.path;
            // If we have a path, we treat it using `treat_object_with_path()`
            match path.len() {
                0 => launch_ui(&RealTuiInput),
                1 => match treat_object_with_path(&path[0], cli.password) {
                    Ok(output) => output.display(),
                    Err(e) => {
                        e.into_output()
                            .with_snippet(Snippet::cli_invocation("eck", &path[0]))
                            .display();
                    }
                },
                _ => match treat_objects_with_multiple_paths(&path, cli.password) {
                    Ok(()) => (),
                    Err(e) => e
                        .into_output()
                        .with_snippet(Snippet::cli_invocation("eck", &path[0]))
                        .display(),
                },
            }
        }
    }
}