Compare commits

..

13 commits

10 changed files with 226 additions and 76 deletions

View file

@ -1,16 +1,15 @@
[package]
name = "oink"
version = "0.0.2"
version = "0.2.3"
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.8.1"
[profile.release]
opt-level = "s"

View file

@ -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

34
man/oink.1 Normal file
View file

@ -0,0 +1,34 @@
.Dd $Mdocdate$
.Dt OINK 1
.Os
.Sh NAME
.Nm oink
.Nd a configuration file preprocessor
.Sh SYNOPSIS
.Nm
.Ar command
.Sh DESCRIPTION
.Nm
is a configuration file preprocessor focused on centralizing configuration changes.
.Ss COMMANDS
.Bl -tag -width Ds
.It apply
Copies the last generated files to their target paths.
.It build
Generates files from their templates.
.It full
Runs 'build', then 'apply'.
.El
.Sh EXIT STATUS
.Bl -tag -width Ds
.It 1
No command was given.
.It 2
The configuration file has no items in the target array.
.It 3
Failed to create the configuration directories.
.El
.Sh AUTHORS
.An -nosplit
.An Valerie Wolfe Aq Mt sleeplessval@gmail.com

View file

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

View file

@ -1,7 +1,7 @@
//! configuration struct and implementations
use std::{
collections::HashMap,
collections::BTreeMap,
env::var,
fs::{ create_dir, read_to_string, File },
io::Error,
@ -9,13 +9,16 @@ use std::{
process::exit
};
use tera::Context;
use upon::Value as ContextValue;
use toml::{
map::Map,
Value
};
use crate::error;
use crate::{ error, util };
pub type Context = BTreeMap<String, ContextValue>;
pub type Table = toml::map::Map<String, Value>;
/// configuration struct
pub struct Config {
@ -53,26 +56,53 @@ impl Config {
}
}
/// build tera context from "vars" and "colors" config sections
pub fn context(&self) -> Context {
/// build context from "vars" and "colors" config sections
pub fn context(&self, target: &Table) -> Context {
let mut output = Context::new();
let mut def: Vec<ContextValue> = Vec::new();
let vars = self.inner.get("vars");
if vars.is_some() {
let vars = vars.unwrap().as_table().unwrap();
// pull global vars
if let Some(Value::Table(vars)) = self.inner.get("vars") {
for (key, value) in vars.iter() {
output.insert(key, value.as_str().unwrap());
let key = key.to_owned();
if let Some(value) = util::convert(value) {
output.insert(key.clone(), value);
def.push(ContextValue::String(key));
}
}
let colors = self.inner.get("colors");
if colors.is_some() {
let colors = colors.unwrap().as_table().unwrap();
let mut map = HashMap::<&str, &str>::new();
for (key, value) in colors.iter() {
map.insert(key, value.as_str().unwrap());
}
output.insert("colors", &map);
// pull target values
for (key, value) in target.iter() {
if key.to_uppercase() == *key {
if let Some(value) = util::convert(value) {
let key = key.to_owned();
output.insert(key.clone(), value);
def.push(ContextValue::String(key));
}
}
}
// pull palette
let palette_name: Option<String> =
if let Some(Value::String(name)) = target.get("use_palette") { Some(name.clone()) }
else if let Some(Value::String(name)) = self.inner.get("use_palette") { Some(name.clone()) }
else { None };
if let Some(Value::Array(array)) = self.inner.get("palette") {
let palette = util::matches(array.to_owned(), palette_name.unwrap_or("default".to_string()));
if let Some(Value::Table(palette)) = palette {
let colors = Context::new();
for(key, value) in palette.iter() {
output.insert(key.to_owned(), value.as_str().unwrap().into());
}
let key = "palette".to_string();
output.insert(key.clone(), colors.into());
def.push(ContextValue::String(key));
}
}
// insert set vars list
output.insert("def".to_string(), def.into());
output
}

View file

@ -3,6 +3,11 @@ use std::{
process::exit
};
pub fn no_command() {
crate::help_text();
exit(1);
}
pub fn no_targets() {
println!("oink: configuration has no targets");
exit(2);

7
src/filter.rs Normal file
View file

@ -0,0 +1,7 @@
use upon::Value;
pub fn has(list: Vec<Value>, key: String) -> bool {
return list.contains(&Value::String(key));
}

View file

@ -1,12 +1,12 @@
#![feature(error_in_core)]
use std::process::exit;
use pico_args::Arguments;
use tera::Tera;
mod config;
mod error;
mod filter;
mod operation;
mod util;
use crate::config::Config;
fn main() {
@ -20,33 +20,27 @@ fn main() {
// init configuration
let config = Config::new();
// tera init
let context = config.context();
let template_dir = format!("{}/templates/*", &(config.dir));
let mut tera = Tera::new(&template_dir).unwrap();
// build template dir
let template_dir = format!("{}/templates/", &(config.dir));
let targets = config.targets();
if targets.len() == 0 { error::no_targets(); }
match operation.as_deref() {
Some("apply")
=> {
operation::apply(&targets);
},
=> operation::apply(&targets),
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);
println!();
operation::apply(&targets);
},
_
=> {
help_text();
exit(1);
}
_ => error::no_command()
}
}

View file

@ -1,28 +1,41 @@
//! higher-level operation functions
use std::{
env::var,
fs::{ self, File },
fs::{self, read_to_string, File },
io::Write,
path::Path
path::{ Path, PathBuf },
time::SystemTime
};
use core::error::Error;
use tera::{ Context, Tera };
use termion::{
color::{ self, Fg },
style
style::{
Bold as BOLD,
Faint as FAINT,
Italic as ITALIC,
Reset as RESET
}
};
use toml::{ map::Map, Value };
use upon::Engine;
static FAIL: Fg<color::LightRed> = Fg(color::LightRed);
static SUCCESS: Fg<color::LightGreen> = Fg(color::LightGreen);
static WARN: Fg<color::Yellow> = Fg(color::Yellow);
static RESET: Fg<color::Reset> = Fg(color::Reset);
use crate::{
config::Config,
filter,
util::time
};
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 start = SystemTime::now();
let home = var("HOME").unwrap();
println!("{}running apply{}", style::Bold, style::Reset);
println!("running apply:");
for target in targets {
let start = SystemTime::now();
// get path and name
let path = target.get("path");
let i_name = target.get("name");
@ -31,12 +44,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!(" {WARN}\"{name}\" is missing its path property; skipping{RESET}");
} else { println!(" {WARN}skipping empty target{RESET}"); }
println!(" {WARNING}\"{name}\" is missing its path property; skipping{RESET}");
} else { println!(" {WARNING}skipping empty target{RESET}"); }
continue;
}
if i_name.is_none() {
println!(" {WARN}target missing name; skipping{RESET}");
println!(" {WARNING}target missing name; skipping{RESET}");
continue;
}
@ -51,20 +64,36 @@ pub fn apply(targets: &Vec<Map<String, Value>>) {
// copy and print
let result = fs::copy(source, destination);
if result.is_err() { println!(" {FAIL}failed to copy!{RESET}"); }
else { println!(" {SUCCESS}completed successfully{RESET}"); }
let time = time(start);
if result.is_err() {
print!(" {BOLD}{FAILURE}failed to copy{RESET}");
}
else {
print!(" {BOLD}{SUCCESS}completed{RESET}");
}
println!(" {FAINT}({time}){RESET}");
}
let time = time(start);
println!("{FAINT}(apply: {time}){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 start = SystemTime::now();
let home = var("HOME").unwrap();
println!("{}running build{}", style::Bold, style::Reset);
println!("running build:");
let mut engine = Engine::new();
engine.add_filter("has", filter::has);
for target in targets {
let start = SystemTime::now();
let context = config.context(target);
// get name property
let i_name = target.get("name");
// handle empty names gracefully
if i_name.is_none() {
println!(" {WARN}target missing name; skipping{RESET}");
println!(" {WARNING}target missing name; skipping{RESET}");
continue;
}
@ -72,16 +101,32 @@ 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
let render = tera.render(name, context);
// handle rendering errors gracefully
if render.is_err() {
let error = render.err().unwrap();
let message = error.source().unwrap();
// compile
let compile_start = SystemTime::now();
print!(" {ITALIC}compiling{RESET}");
let mut path = PathBuf::from(&template_dir);
if let Some(Value::String(base)) = target.get("base") { path.push(base); }
else { path.push(name); }
println!(" {FAIL}failed to render template:\n {message}{RESET}");
let content = read_to_string(path).unwrap();
let template = engine.compile(&content);
let compile_time = time(compile_start);
print!(" {FAINT}({compile_time}){RESET}");
if let Err(error) = template {
println!("\n {BOLD}{FAILURE}failed to compile template:{RESET}\n {FAILURE}{error}\n {BOLD}skipping{RESET}");
continue;
}
} else { println!(); }
// render
let render_start = SystemTime::now();
print!(" {ITALIC}rendering{RESET}");
let render = template.unwrap().render(&engine, &context).to_string();
let render_time = time(render_start);
print!(" {FAINT}({render_time}){RESET}");
if let Err(error) = render {
println!("\n {BOLD}{FAILURE}failed to render template:{RESET}\n {FAILURE}{error}\n {BOLD}skipping{RESET}");
continue;
} else { println!(); }
// get rendered text and open destination file
let output = render.unwrap();
@ -89,14 +134,19 @@ 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!(" {FAIL}failed to create destination file at {path:?}{RESET}");
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!(" {FAIL}failed to write to destination file at {path:?}{RESET}"); }
else { println!(" {SUCCESS}completed successfully{RESET}"); }
if written.is_err() { println!(" {FAILURE}failed to write to destination file at {path:?}{RESET}"); }
else {
let time = time(start);
println!(" {BOLD}{SUCCESS}completed{RESET} {FAINT}({time}){RESET}");
}
}
let time = time(start);
println!("{FAINT}(build: {time}){RESET}");
}

35
src/util.rs Normal file
View file

@ -0,0 +1,35 @@
use std::time::SystemTime;
use upon::Value as ContextValue;
use toml::{ value::Array, Value };
pub fn matches(array: Array, to_match: String) -> Option<Value> {
array.iter().filter(|value| {
if let Value::Table(table) = value {
if let Some(Value::String(name)) = table.get("name") {
return *name == to_match;
}
}
return false;
}).map(|value| value.to_owned()).nth(0)
}
pub fn convert(value: &Value) -> Option<ContextValue> {
match value.clone() {
Value::Boolean(bool) => Some(bool.into()),
Value::Float(float) => Some(float.into()),
Value::Integer(int) => Some(int.into()),
Value::String(string) => Some(string.into()),
_ => None
}
}
pub fn time(start: SystemTime) -> String {
let now = SystemTime::now();
if let Ok(duration) = now.duration_since(start) {
let ms = duration.as_millis();
if ms > 0 { format!("{ms} ms") }
else { "< 1 ms".to_owned() }
} else { String::new() }
}