gave context items module structure, moved context build to a new method, and implemented empty and set flags

Cargo.toml

@@ -14,6 +14,7 @@ path = "src/main.rs"
 
 [dependencies]
 evalexpr = "11.0.0"
+pico-args = "0.5.0"
 termion = "1.5.6"
 
 [profile.release]

src/context/mod.rs

@@ -0,0 +1,4 @@
+
+pub mod global;
+pub mod helper;
+

src/flag.rs

@@ -0,0 +1,7 @@
+
+pub const EMPTY_CONTEXT:	[&str;2]	=	[ "-E", "--empty"];
+pub const HELP:				[&str;2]	=	[ "-h", "--help" ];
+pub const QUIET:			[&str;2]	=	[ "-q", "--quiet" ];
+pub const SET:				&str		=	"--set";
+pub const VERSION:			[&str;2]	=	[ "-V", "--version" ];
+

src/main.rs

@@ -9,64 +9,50 @@ use std::{
 };
 
 use evalexpr::{
-	context_map,
 	eval_with_context_mut,
 	ContextWithMutableVariables,
 	HashMapContext,
 	Value
 };
+use pico_args::Arguments;
 use termion::{
 	color,
 	style
 };
 
-mod global;
+mod context;
-mod helper;
+mod eval;
+mod flag;
 mod util;
 
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 fn main() {
-	//	build eval context
+	let mut args = Arguments::from_env();
-	let mut context = context_map! {
-		//	globals
-		"c"		=>	global::LIGHT_SPEED,
-		"e"		=>	global::EULER,
-		"phi"	=>	global::GOLDEN_RATIO,
-		"pi"	=>	global::PI,
-		"√2"	=>	global::ROOT_TWO,
 
-		//	math functions
+	//	handle breaking flags
-		"fix"	=>	Function::new(|arg| helper::fix(arg)),
+	if args.contains(flag::HELP) {
-		"log"	=>	Function::new(|arg| helper::logarithm(arg)),
+		help_text();
-		"sqrt"	=>	Function::new(|arg| helper::square_root(arg)),
+		return;
+	}
+	if args.contains(flag::VERSION) {
+		version_text();
+		return;
+	}
 
-		//	data science functions
+	let mut context = util::build_context(&mut args);
-		"avg"	=>	Function::new(|arg| helper::average(arg)),
-
-		//	radix functions
-		"bin"	=>	Function::new(|arg| helper::binary(arg)),
-		"hex"	=>	Function::new(|arg| helper::hexadecimal(arg)),
-		"oct"	=>	Function::new(|arg| helper::octal(arg)),
-
-		//	character aliases
-		"ϕ"		=>	global::GOLDEN_RATIO,
-		"π"		=>	global::PI,
-		"√"		=>	Function::new(|arg| helper::square_root(arg))
-	}.unwrap();
 
 	//	collect args and evaluate if present
-	let expressions: Vec<String> = env::args().skip(1).collect();
+	let expressions = args.finish();
 	if expressions.len() > 0 {
 		for expression in expressions {
-			match expression.as_str() {
+			let expression: String = expression.to_string_lossy().into();
-				"help"	=>	help_text(),
+			do_eval(expression, &mut context)
-				_		=>	do_eval(expression, &mut context)
-			}
 		}
 	} else {
 		//	enter interactive mode if no args are given
-		println!("{}quickmaths v{}{}\n{}Interactive Mode{}", style::Bold, VERSION, style::Reset, style::Faint, style::Reset);
+		version_text();
+		println!("{}Interactive Mode{}", style::Faint, style::Reset);
 		loop {
 			print!("> ");
 			stdout().flush().unwrap();
@@ -131,16 +117,17 @@ fn reset() {
 	stdout().flush().unwrap();
 }
 
+fn version_text() {
+	println!("qm v{VERSION}");
+}
+
 fn help_text() {
+	version_text();
 	println!(
-		"{bold}quickmaths v{version}{reset}
+"Valerie Wolfe <sleeplessval@gmail.com>
-Valerie Wolfe <sleeplessval@gmail.com>
 A mathematical expression evaluator written in Rust.
 
 usage:
-   qm [EXPRESSION]...",
+   qm [EXPRESSION]..."
-		bold = style::Bold,
-		reset = style::Reset,
-		version = crate::VERSION
 	);
 }

src/util.rs

@@ -1,7 +1,12 @@
-use evalexpr::{
-	Value,
 
-	EvalexprError
+use evalexpr::{
+	context_map, ContextWithMutableVariables, EvalexprError, HashMapContext, Value
+};
+use pico_args::Arguments;
+
+use crate::{
+	context::{ global, helper },
+	flag
 };
 
 pub(crate) fn parse_radix(prefix: &str, base: u32, arg: &Value) -> Result<Value, EvalexprError> {
@@ -16,3 +21,53 @@ pub(crate) fn parse_radix(prefix: &str, base: u32, arg: &Value) -> Result<Value,
 
 	return Ok(result.unwrap().into());
 }
+
+pub(crate) fn build_context(args: &mut Arguments) -> HashMapContext {
+	let mut output =
+		if !args.contains(flag::EMPTY_CONTEXT) {
+			context_map! {
+				//	globals
+				"c"		=>	global::LIGHT_SPEED,
+				"e"		=>	global::EULER,
+				"phi"	=>	global::GOLDEN_RATIO,
+				"pi"	=>	global::PI,
+				"√2"	=>	global::ROOT_TWO,
+
+				//	math functions
+				"fix"	=>	Function::new(|arg| helper::fix(arg)),
+				"log"	=>	Function::new(|arg| helper::logarithm(arg)),
+				"sqrt"	=>	Function::new(|arg| helper::square_root(arg)),
+
+				//	data science functions
+				"avg"	=>	Function::new(|arg| helper::average(arg)),
+
+				//	radix functions
+				"bin"	=>	Function::new(|arg| helper::binary(arg)),
+				"hex"	=>	Function::new(|arg| helper::hexadecimal(arg)),
+				"oct"	=>	Function::new(|arg| helper::octal(arg)),
+
+				//	character aliases
+				"ϕ"		=>	global::GOLDEN_RATIO,
+				"π"		=>	global::PI,
+				"√"		=>	Function::new(|arg| helper::square_root(arg))
+			}.unwrap()
+		} else { HashMapContext::new() };
+
+	while let Ok(value) = args.value_from_str::<&str, String>(flag::SET) {
+		let split: Vec<&str> = value.split('=').collect();
+		if split.len() == 2 {
+			let key = split[0].to_owned();
+
+			let value_str = split[1];
+			let value =
+				if let Ok(integer) = value_str.parse::<i64>() { Value::Int(integer) }
+				else if let Ok(float) = value_str.parse::<f64>() { Value::Float(float) }
+				else { Value::from(value_str) };
+
+			output.set_value(key, value).ok(); }
+		else { std::process::exit(1); }
+	}
+
+	output
+}
+