Added Custom Array and Object Formatters

Improved IonObject;:keys to return keys as strings
Added globals and microtask queue to eval subcommand
Fixed underflow on u16 when counting brackets in REPL
Replaced termcolor with colored
Added .gitattributes

Author: redfire75369

.gitattributes

@@ -0,0 +1,28 @@
+* text=auto eol=lf
+
+*.rs text
+*.js text
+*.ts text
+*.js.flow text
+*.md text
+
+*.toml text
+*.yml text
+
+*.editorconfig text
+*.gitattributes text
+*.gitignore text
+
+Cargo.lock text
+
+*.bat text eol=crlf
+*.cmd text eol=crlf
+*.ps1 text eol=crlf
+*.sh text
+
+*.gif binary
+*.ico binary
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.svg text

Cargo.lock

@@ -6,6 +6,7 @@ authors = ["Redfire <redfire75369@hotmail.com>"]
 license = "MPL-2.0"
 
 [dependencies]
+colored = "2.0.0"
 structopt = "0.3.25"
 ion = { path = "../ion" }
 modules = { path = "../modules" }

cli/Cargo.toml

@@ -4,14 +4,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-use runtime::globals::new_global;
+use runtime::globals::{init_globals, new_global};
+use runtime::microtask_queue::init_microtask_queue;
 use runtime::new_runtime;
 
 use crate::evaluate::eval_inline;
 
 pub fn eval_source(source: &str) {
 	let (_engine, rt) = new_runtime();
-	let (_global, _ac) = new_global(rt.cx());
+	let (global, _ac) = new_global(rt.cx());
+
+	init_globals(rt.cx(), global);
+	init_microtask_queue(rt.cx());
 
 	eval_inline(&rt, source);
 }

cli/src/commands/eval.rs

@@ -27,7 +27,7 @@ pub fn start_repl() {
 	loop {
 		let mut input = String::new();
 		let mut lines = 0;
-		let mut multiline: (u16, u16, u16) = (0, 0, 0); // (), [], {}
+		let mut multiline: (i16, i16, i16) = (0, 0, 0); // (), [], {}
 		loop {
 			let mut line = String::new();
 

cli/src/commands/repl.rs

@@ -9,8 +9,9 @@ use std::path::Path;
 
 use mozjs::rust::Runtime;
 
+use ion::format::config::Config;
+use ion::format::format_value;
 use ion::script::IonScript;
-use ion::types::string::to_string;
 use modules::init_modules;
 use runtime::globals::{init_globals, new_global};
 use runtime::microtask_queue::init_microtask_queue;
@@ -19,7 +20,7 @@ use runtime::new_runtime;
 
 pub fn eval_inline(rt: &Runtime, source: &str) {
 	match IonScript::compile_and_evaluate(rt.cx(), "inline.js", source) {
-		Ok(v) => println!("{}", to_string(rt.cx(), v)),
+		Ok(v) => println!("{}", format_value(rt.cx(), Config::default().quoted(true), v)),
 		Err(e) => e.print(),
 	}
 }
@@ -33,7 +34,7 @@ pub fn eval_script(path: &Path) {
 
 	let script = read_script(path).expect("");
 	match IonScript::compile_and_evaluate(rt.cx(), &path.file_name().unwrap().to_str().unwrap(), &script) {
-		Ok(v) => println!("{}", to_string(rt.cx(), v)),
+		Ok(v) => println!("{}", format_value(rt.cx(), Config::default().quoted(true), v)),
 		Err(e) => e.print(),
 	}
 }

cli/src/evaluate.rs

@@ -10,7 +10,6 @@ use runtime::config::{Config, CONFIG, LogLevel};
 
 use crate::commands::{repl, run};
 use crate::commands::eval;
-use crate::Commands::{Eval, Repl, Run};
 
 mod commands;
 pub mod evaluate;
@@ -19,11 +18,11 @@ pub mod evaluate;
 #[structopt(name = "spiderfire", about = "JavaScript Runtime")]
 struct Cli {
 	#[structopt(subcommand)]
-	commands: Option<Commands>,
+	command: Option<Command>,
 }
 
 #[derive(StructOpt)]
-pub enum Commands {
+pub enum Command {
 	#[structopt(about = "Evaluates a line of JavaScript")]
 	Eval {
 		#[structopt(required(true), about = "Line of JavaScript to be evaluated")]
@@ -35,13 +34,13 @@ pub enum Commands {
 
 	#[structopt(about = "Runs a JavaScript file")]
 	Run {
-		#[structopt(about = "The JavaScript file to run. Default: 'main.js'", required(false), default_value = "main.js")]
+		#[structopt(about = "The JavaScript file to run, Default: 'main.js'", required(false), default_value = "main.js")]
 		path: String,
 
-		#[structopt(about = "Sets logging level, Default: ERROR", short, long, required(false), default_value = "error")]
+		#[structopt(about = "Sets logging level, Default: ERROR", short, long, required(false), default_value = "ERROR")]
 		log_level: String,
 
-		#[structopt(about = "Sets logging level to DEBUG.", short, long)]
+		#[structopt(about = "Sets logging level to DEBUG", short, long)]
 		debug: bool,
 
 		#[structopt(about = "Disables ES Modules Features", short, long)]
@@ -52,23 +51,27 @@ pub enum Commands {
 fn main() {
 	let args = Cli::from_args();
 
-	match args.commands {
-		Some(Eval { source }) => {
+	#[cfg(windows)]
+	{
+		colored::control::set_virtual_terminal(true).unwrap();
+	}
+
+	match args.command {
+		Some(Command::Eval { source }) => {
 			CONFIG
 				.set(Config::default().log_level(LogLevel::Debug).script(true))
 				.expect("Config Initialisation Failed");
 			eval::eval_source(&source);
 		}
 
-		Some(Run {
+		Some(Command::Run {
 			path,
 			log_level,
 			debug,
 			script,
 		}) => {
-
 			let log_lev = if debug {
-				 LogLevel::Debug
+				LogLevel::Debug
 			} else {
 				match log_level.to_uppercase().as_str() {
 					"NONE" => LogLevel::None,
@@ -86,7 +89,7 @@ fn main() {
 			run::run(&path);
 		}
 
-		Some(Repl) | None => {
+		Some(Command::Repl) | None => {
 			CONFIG
 				.set(Config::default().log_level(LogLevel::Debug).script(true))
 				.expect("Config Initialisation Failed");

cli/src/main.rs

@@ -7,12 +7,12 @@ license = "MPL-2.0"
 
 [dependencies]
 chrono = "0.4.19"
-futures = { version = "0.3.17", features = ["executor"]}
+colored = "2.0.0"
+futures = { version = "0.3.17", features = ["executor"] }
 ion-proc = { path = "../ion-proc" }
 libffi = "2.0.0"
 mozjs = { package = "mozjs", git = "https://github.com/servo/rust-mozjs" }
 mozjs_sys = { package = "mozjs_sys", git = "https://github.com/servo/mozjs", rev = "de147f0cf52da9c84fa95edf09c5f9f84695088c" }
-termcolor = "1.1.2"
 
 [features]
 debugmozjs = ["mozjs/debugmozjs"]

ion/Cargo.toml

@@ -0,0 +1,61 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+use colored::Colorize;
+
+use crate::format::{format_value, INDENT, NEWLINE};
+use crate::format::config::Config;
+use crate::IonContext;
+use crate::objects::array::IonArray;
+
+/// Formats an [IonArray] to a [String] using the given configuration options
+pub fn format_array(cx: IonContext, cfg: Config, array: IonArray) -> String {
+	let color = cfg.colors.array;
+	if cfg.depth < 5 {
+		unsafe {
+			let vec = array.to_vec(cx);
+			let vec_length = vec.len();
+
+			if vec_length == 0 {
+				"[]".color(color).to_string()
+			} else {
+				let mut string = format!("[{}", NEWLINE).color(color).to_string();
+				let length = vec_length.clamp(0, 100);
+				let remaining = vec_length - length;
+
+				let inner_indent = INDENT.repeat((cfg.indentation + cfg.depth + 1) as usize);
+				let outer_indent = INDENT.repeat((cfg.indentation + cfg.depth) as usize);
+				for i in 0..length {
+					let value = vec[i];
+					let value_string = format_value(cx, cfg.depth(cfg.depth + 1).quoted(true), value);
+					string.push_str(&inner_indent);
+					string.push_str(&value_string);
+
+					if i != vec_length - 1 {
+						string.push_str(&format!(",{}", NEWLINE).color(color).to_string());
+					} else {
+						string.push_str(NEWLINE);
+					}
+				}
+
+				if remaining > 0 {
+					string.push_str(&inner_indent);
+					if remaining == 1 {
+						string.push_str(&"... 1 more item".color(color).to_string());
+					} else if remaining > 1 {
+						string.push_str(&format!("... {} more items", remaining).color(color).to_string());
+					}
+				}
+
+				string.push_str(&outer_indent);
+				string.push_str(&"]".color(color).to_string());
+				string
+			}
+		}
+	} else {
+		"[Array]".color(color).to_string()
+	}
+}

ion/src/format/array.rs

@@ -0,0 +1,32 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+use mozjs::jsapi::js::{ESClass, Unbox};
+
+use crate::format::config::Config;
+use crate::format::primitive::format_primitive;
+use crate::IonContext;
+use crate::objects::object::{IonObject, IonRawObject};
+
+/// Formats a boxed object to a [String] using the given configuration options
+/// Supported types are `Boolean`, `Number`, `String` and `BigInt`
+pub fn format_boxed(cx: IonContext, cfg: Config, object: IonRawObject, class: ESClass) -> String {
+	rooted!(in(cx) let robj = object);
+	rooted!(in(cx) let mut unboxed = IonObject::new(cx).to_value());
+
+	unsafe {
+		if Unbox(cx, robj.handle().into(), unboxed.handle_mut().into()) {
+			use ESClass::*;
+			match class {
+				Boolean | Number | String => format_primitive(cx, cfg, unboxed.get()),
+				BigInt => format!("Unimplemented Formatting: {}", "BigInt"),
+				_ => unreachable!(),
+			}
+		} else {
+			String::from("Boxed Value")
+		}
+	}
+}