r-env 0.9.1

CLI utility for .env file
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

//!
//! r-env: CLI utility for .env
//!  

mod app;
mod env;

/// Shows usage.
fn usage() {
	let pkg_name = env!("CARGO_PKG_NAME");
	eprintln!("Usage: {} [OPTIONS] [COMMAND]", pkg_name);
	eprintln!();
	eprintln!("Options:");
	eprintln!("        --dump              Dump variables.");
	eprintln!("    -h, --help              usage");
	eprintln!("        --use-stdin         Use command stdin as .env");
	eprintln!("        --file STRING       .env");
}

/// Configuration class
#[derive(Debug)]
struct Configuration {
	/// Command line arguments.
	command: Vec<String>,

	/// Dump variables.
	dump: bool,

	/// .env file path.
	file: Option<String>,

	/// Show help.
	help: bool,

	/// Use stdin as .env
	use_stdin: bool,
}

impl Configuration {
	/// Create a new instance.
	pub fn new(args: &Vec<String>) -> Result<Self, Box<dyn std::error::Error>> {
		let mut conf = Self {
			command: vec![],
			dump: false,
			file: None,
			help: false,
			use_stdin: false,
		};

		// ========== PARSE ARGUMENTS ==========
		let mut current_section = "";

		for arg in args {
			if 0 < conf.command.len() {
				conf.command.push(arg.to_string());
			} else if arg == "--" {
				// end of section
				current_section = "";
				conf.command.push(arg.to_string());
			} else if arg == "--dump" {
				conf.dump = true;
				current_section = "";
			} else if arg == "--file" {
				conf.file = Some("".to_string());
				current_section = "--file";
			} else if arg == "--help" {
				conf.help = true;
				current_section = "";
			} else if arg == "-h" {
				conf.help = true;
				current_section = "";
			} else if arg == "--use-stdin" {
				conf.use_stdin = true;
				current_section = ""
			} else if arg.starts_with("-") {
				let err = format!("Unknown option {}.", arg);
				return Err(err.into());
			} else if current_section == "--file" {
				conf.file = Some(arg.to_string());
				current_section = "";
			} else {
				conf.command.push(arg.to_string());
			}
		}

		// ========== VALIDATE ARGUMENTS ==========

		if conf.file.is_some() {
			let file = conf.file.as_ref().unwrap();
			if file == "" {
				let error = "--file option requires a file path.";
				return Err(error.into());
			}
		}

		return Ok(conf);
	}
}

/// Entrypoint of a Rust application.
fn main() {
	// ========== PARSE ARGUMENTS ==========
	let args: Vec<String> = std::env::args().skip(1).collect();
	let result = Configuration::new(&args);
	if result.is_err() {
		let pkg_name = env!("CARGO_PKG_NAME");
		eprintln!("{}: {}", pkg_name, result.err().unwrap());
		eprintln!();
		usage();
		std::process::exit(1);
	}
	let input = result.unwrap();

	if input.help {
		// ========== SHOW HELP ==========
		usage();
	} else if input.dump {
		// ========== DUMP VARIABLES ==========
		let app = app::Application;
		let result = app.dump_variables(input.use_stdin, input.file);
		if result.is_err() {
			let pkg_name = env!("CARGO_PKG_NAME");
			eprintln!("{}: {}", pkg_name, result.err().unwrap());
			eprintln!();
			usage();
			std::process::exit(1);
		}
	} else {
		// ========== EXECUTE READ ENV AND PASS TO NEXT COMMAND ==========
		let app = app::Application;
		let result = app.execute(input.use_stdin, input.file, &input.command);
		if result.is_err() {
			eprintln!("ERROR: {}", result.err().unwrap());
			std::process::exit(1);
		}
		let exit_code = result.unwrap();
		if exit_code != 0 {
			std::process::exit(exit_code);
		}
	};
}