feat: add ability to globally work with environment variables

Author: ankddev

Cargo.lock

@@ -20,6 +20,8 @@ similar-string = "1.4.3"
 subprocess = "0.2.9"
 # Parsing dotenv-style files
 dotenv-parser = "0.1.3"
+# Globally setting variables
+globalenv = "0.4.2"
 
 [dev-dependencies]
 # Asserting CLI programs

Cargo.toml

@@ -15,12 +15,9 @@
 - [x] Print all environment variables
 - [x] Get value of variable by name
     - [x] Show similar variables if variable not found
-- [x] Set variable
-- [x] Delete variable
-- [x] Load variables from dotenv-style file
-- [ ] Globally set variables
-- [ ] Globally delete variables
-- [ ] Globally load variables from dotenv-style file
+- [x] Set variable (temporary and permanent)
+- [x] Delete variable (temporary and permanent)
+- [x] Load variables from dotenv-style file (temporary and permanent)
 - [ ] Set and delete multiple variables at once
 # Get started
 ## Installing
@@ -42,11 +39,9 @@ You can run `envfetch help` to see help message or `envfetch --version` to see p
 ### Command list
 #### Set
 Set environment variable and run process.
-> [!NOTE]
-> Now variable sets only for one run
 
 Usage:
-`envfetch set <KEY> <VALUE> <PROCESS>`, where:
+`envfetch set <KEY> <VALUE> [PROCESS]`, where:
 - `KEY` - name of environment variable
 - `VALUE` - value of environment variable
 - `PROCESS` - name of process which you want to run

README.md

@@ -63,9 +63,12 @@ pub struct GetArgs {
 
 #[derive(Args, Debug)]
 pub struct LoadArgs {
-    /// Process to start
-    #[arg(required = true)]
-    process: String,
+    /// Globally set variable
+    #[arg(required = false, long, short)]
+    global: bool,
+    /// Process to start, not required if --global flag is set
+    #[arg(required_unless_present = "global")]
+    process: Option<String>,
     /// Relative or absolute path to file to read variables from.
     /// Note that it must in .env format
     #[arg(long, short, default_value = ".env")]
@@ -81,9 +84,12 @@ pub struct SetArgs {
     /// Value for environment variable
     #[arg(required = true)]
     value: String,
-    /// Process to start
-    #[arg(required = true)]
-    process: String,
+    /// Globally set variable
+    #[arg(required = false, long, short)]
+    global: bool,
+    /// Process to start, not required if --global flag is set
+    #[arg(required_unless_present = "global")]
+    process: Option<String>,
 }
 
 /// Args for delete command
@@ -92,9 +98,19 @@ pub struct DeleteArgs {
     /// Environment variable name
     #[arg(required = true)]
     key: String,
-    /// Process to start
-    #[arg(required = true)]
-    process: String,
+    /// Globally set variable
+    #[arg(required = false, long, short)]
+    global: bool,
+    /// Process to start, not required if --global flag is set
+    #[arg(required_unless_present = "global")]
+    process: Option<String>,
+}
+
+fn validate_var_name(name: &str) -> Result<(), String> {
+    if name.contains(' ') {
+        return Err("Variable name cannot contain spaces".into());
+    }
+    Ok(())
 }
 
 fn main() {
@@ -151,37 +167,73 @@ fn main() {
                     match dotenv_parser::parse_dotenv(&content) {
                         Ok(variables) => {
                             for (key, value) in variables.into_iter() {
-                                unsafe { env::set_var(key, value) };
+                                if opt.global {
+                                    if let Err(err) = globalenv::set_var(&key, &value) {
+                                        error(&format!("can't globally set variables: {}", err), cli.exit_on_error);
+                                    }
+                                } else {
+                                    unsafe { env::set_var(key, value) };
+                                }
+                            }
+                            if let Some(process) = opt.process {
+                                run(process, cli.exit_on_error);
                             }
-                            run(opt.process, cli.exit_on_error);
                         }
                         Err(err) => {
                             error(err.to_string().as_str(), cli.exit_on_error);
-                            run(opt.process, cli.exit_on_error);
+                            if let Some(process) = opt.process {
+                                run(process, cli.exit_on_error);
+                            }
                             process::exit(1);
                         }
                     }
                 }
                 Err(err) => {
                     error(err.to_string().as_str(), cli.exit_on_error);
-                    run(opt.process, cli.exit_on_error);
+                    if let Some(process) = opt.process {
+                        run(process, cli.exit_on_error);
+                    }
                     process::exit(1);
                 }
             }
         }
         // Set command handler
         Commands::Set(opt) => {
-            unsafe { env::set_var(opt.key, opt.value) };
-            run(opt.process, cli.exit_on_error);
+            if let Err(err) = validate_var_name(&opt.key) {
+                error(&err, cli.exit_on_error);
+                process::exit(1);
+            }
+
+            if opt.global {
+                if let Err(err) = globalenv::set_var(&opt.key, &opt.value) {
+                    error(&format!("can't globally set variable: {}", err), cli.exit_on_error);
+                    process::exit(1);
+                }
+            } else {
+                unsafe { env::set_var(opt.key, opt.value) };
+            }
+            if let Some(process) = opt.process {
+                run(process, cli.exit_on_error);
+            }
         }
         // Delete command handler
         Commands::Delete(opt) => {
             // Check if variable exists
             match env::var(&opt.key) {
-                Ok(_) => unsafe { env::remove_var(&opt.key) },
+                Ok(_) => {
+                    if opt.global {
+                        if let Err(err) = globalenv::unset_var(&opt.key) {
+                            error(&format!("can't globally delete variable: {}", err), cli.exit_on_error);
+                        }
+                    } else {
+                        unsafe { env::remove_var(&opt.key) }
+                    }
+                },
                 _ => warning("variable doesn't exists"),
             }
-            run(opt.process, cli.exit_on_error);
+            if let Some(process) = opt.process {
+                run(process, cli.exit_on_error);
+            }
         }
     }
 }