added ANSI formatting for better output readability

Cargo.toml

@@ -1,15 +1,15 @@
 [package]
 name = "oink"
-version = "0.0.2"
+version = "0.1.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-#copy_dir = "0.1.3"
 pico-args = "0.5.0"
-tera = "1.19.0"
+termion = "2.0.1"
 toml = "0.7.6"
+upon = "0.7.1"
 
 [profile.release]
 opt-level = "s"

README.md

@@ -41,6 +41,6 @@ path = "/home/test/.config/oink/oink.toml"
 ## Libraries
 
 - [pico-args](https://crates.io/crates/pico-args) — argument parsing
-- [tera](https://crates.io/crates/tera) — template engine
+- [termion](https://crates.io/crates/termion) — ANSI formatting
 - [toml](https://crates.io/crates/toml) — configuration parsing
-
+- [upon](https://crates.io/crates/upon) — template engine

rust-toolchain.toml

@@ -1,4 +0,0 @@
-
-[toolchain]
-channel = "nightly"
-

src/config.rs

@@ -1,7 +1,7 @@
 //!	configuration struct and implementations
 
 use std::{
-	collections::HashMap,
+	collections::{ BTreeMap, HashMap },
 	env::var,
 	fs::{ create_dir, read_to_string, File },
 	io::Error,
@@ -9,7 +9,7 @@ use std::{
 	process::exit
 };
 
-use tera::Context;
+use upon::Value as ContextValue;
 use toml::{
 	map::Map,
 	Value
@@ -17,6 +17,8 @@ use toml::{
 
 use crate::error;
 
+pub type Context = BTreeMap<String, ContextValue>;
+
 ///	configuration struct
 pub struct Config {
 	pub dir: String,
@@ -61,17 +63,17 @@ impl Config {
 		if vars.is_some() {
 			let vars = vars.unwrap().as_table().unwrap();
 			for (key, value) in vars.iter() {
-				output.insert(key, value.as_str().unwrap());
+				output.insert(key.to_owned(), value.as_str().into());
 			}
 		}
 		let colors = self.inner.get("colors");
 		if colors.is_some() {
 			let colors = colors.unwrap().as_table().unwrap();
-			let mut map = HashMap::<&str, &str>::new();
+			let mut map = Context::new();
 			for (key, value) in colors.iter() {
-				map.insert(key, value.as_str().unwrap());
+				map.insert(key.to_owned(), value.as_str().unwrap().into());
 			}
-			output.insert("colors", &map);
+			output.insert("colors".to_owned(), map.into());
 		}
 
 		output

src/main.rs

@@ -1,12 +1,11 @@
-#![feature(error_in_core)]
 use std::process::exit;
 
 use pico_args::Arguments;
-use tera::Tera;
 
 mod config;
 mod error;
 mod operation;
+
 use crate::config::Config;
 
 fn main() {
@@ -20,10 +19,8 @@ fn main() {
 	//	init configuration
 	let config = Config::new();
 
-	//	tera init
+	//	build template dir
-	let context = config.context();
+	let template_dir = format!("{}/templates/", &(config.dir));
-	let template_dir = format!("{}/templates/*", &(config.dir));
-	let mut tera = Tera::new(&template_dir).unwrap();
 
 	let targets = config.targets();
 	if targets.len() == 0 { error::no_targets(); }
@@ -35,11 +32,11 @@ fn main() {
 			},
 		Some("build")
 			=> {
-				operation::build(&targets, &mut tera, &context);
+				operation::build(&targets, template_dir, &config);
 			},
 		Some("full")
 			=> {
-				operation::build(&targets, &mut tera, &context);
+				operation::build(&targets, template_dir, &config);
 				operation::apply(&targets);
 			},
 		_

src/operation.rs

@@ -1,14 +1,27 @@
 //!	higher-level operation functions
 use std::{
 	env::var,
-	fs::{ self, File },
+	fs::{self, read_to_string, File },
 	io::Write,
-	path::Path
+	path::{ Path, PathBuf }
 };
-use core::error::Error;
 
+use termion::{
+	color::{ self, Fg },
+	style::{
+		Bold as BOLD,
+		Italic as ITALIC,
+		Reset as RESET
+	}
+};
 use toml::{ map::Map, Value };
-use tera::{ Context, Tera };
+use upon::Engine;
+
+use crate::config::Config;
+
+static SUCCESS: Fg<color::Green>	= Fg(color::Green);
+static WARNING: Fg<color::Yellow>	= Fg(color::Yellow);
+static FAILURE: Fg<color::Red>		= Fg(color::Red);
 
 pub fn apply(targets: &Vec<Map<String, Value>>) {
 	let home = var("HOME").unwrap();
@@ -22,12 +35,12 @@ pub fn apply(targets: &Vec<Map<String, Value>>) {
 		if path.is_none() {
 			if i_name.is_some() {
 				let name = i_name.unwrap().as_str().unwrap();
-				println!("  \"{name}\" is missing its path property; skipping");
+				println!("  {WARNING}\"{name}\" is missing its path property; skipping{RESET}");
-			} else { println!("  skipping empty target"); }
+			} else { println!("  {WARNING}skipping empty target{RESET}"); }
 			continue;
 		}
 		if i_name.is_none() {
-			println!("  target missing name; skipping");
+			println!("  {WARNING}target missing name; skipping{RESET}");
 			continue;
 		}
 
@@ -42,20 +55,28 @@ pub fn apply(targets: &Vec<Map<String, Value>>) {
 
 		//	copy and print
 		let result = fs::copy(source, destination);
-		if result.is_err() { println!("    failed to copy!"); }
+		if result.is_err() {
-		else { println!("    completed successfully"); }
+			println!("    {BOLD}{FAILURE}failed to copy{RESET}");
+		}
+		else {
+			println!("    {BOLD}{SUCCESS}completed{RESET}");
+		}
 	}
 }
 
-pub fn build(targets: &Vec<Map<String, Value>>, tera: &mut Tera, context: &Context) {
+pub fn build(targets: &Vec<Map<String, Value>>, template_dir: String, config: &Config) {
 	let home = var("HOME").unwrap();
 	println!("running build:");
+
+	let engine = Engine::new();
+	let context = config.context();
+
 	for target in targets {
 		//	get name property
 		let i_name = target.get("name");
 		//	handle empty names gracefully
 		if i_name.is_none() {
-			println!("  target missing name; skipping");
+			println!("  {WARNING}target missing name; skipping{RESET}");
 			continue;
 		}
 
@@ -63,14 +84,24 @@ pub fn build(targets: &Vec<Map<String, Value>>, tera: &mut Tera, context: &Conte
 		let name = i_name.unwrap().as_str().unwrap();
 		println!("  building \"{name}\":");
 
-		//	render template
+		//	compile
-		let render = tera.render(name, context);
+		println!("    {ITALIC}compiling{RESET}");
-		//	handle rendering errors gracefully
+		let mut path = PathBuf::from(&template_dir);
+		path.push(name);
+		let content = read_to_string(path).unwrap();
+		let template = engine.compile(&content);
+		if template.is_err() {
+			let error = template.err().unwrap();
+			println!("      {BOLD}{FAILURE}failed to compile template:{RESET}\n        {FAILURE}{error}\n        {BOLD}skipping{RESET}");
+			continue;
+		}
+
+		//	render
+		println!("    {ITALIC}rendering{RESET}");
+		let render = template.unwrap().render(&context).to_string();
 		if render.is_err() {
 			let error = render.err().unwrap();
-			let message = error.source().unwrap();
+			println!("      {BOLD}{FAILURE}failed to render template:{RESET}\n        {FAILURE}{error}\n      {BOLD}skipping{RESET}");
-
-			println!("   failed to render template:\n      {message}");
 			continue;
 		}
 
@@ -80,14 +111,14 @@ pub fn build(targets: &Vec<Map<String, Value>>, tera: &mut Tera, context: &Conte
 		let path = Path::new(&destination);
 		let i_file = File::create(path);
 		if i_file.is_err() {
-			println!("    failed to create destination file at {path:?}");
+			println!("    {BOLD}{FAILURE}failed to create destination file at {path:?}{RESET}");
 			continue;
 		}
 		let mut file = i_file.unwrap();
 		//	write to destination file
 		let written = write!(&mut file, "{output}");
-		if written.is_err() { println!("    failed to write to destination file at {path:?}"); }
+		if written.is_err() { println!("    {FAILURE}failed to write to destination file at {path:?}{RESET}"); }
-		else { println!("    completed successfully"); }
+		else { println!("    {BOLD}{SUCCESS}completed{RESET}"); }
 	}
 }