From 8119bf8c230be00cf52e22ddd619a94bfd09ba5a Mon Sep 17 00:00:00 2001 From: JesusPerez Date: Sun, 23 Jan 2022 02:18:12 +0000 Subject: [PATCH] chore: add code --- Cargo.toml | 33 ++++++++ rustfmt.toml | 36 ++++++++ src/main.rs | 35 ++++++++ src/tera_lib.rs | 217 ++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 321 insertions(+) create mode 100644 Cargo.toml create mode 100644 rustfmt.toml create mode 100644 src/main.rs create mode 100644 src/tera_lib.rs diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..f98b8cc --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,33 @@ +[package] +name = "rtplfile" +version = "0.1.0" +authors = ["JesusPerez "] +edition = "2021" + +[dependencies] +clap = { version = "3.0.10", features = ["derive"] } +stderrlog = "0.5" +structopt = "0.3" +anyhow = "1.0.38" +faccess = "0.2.3" +serde = { version = "1.0", features = ["derive"] } +serde_derive = "1.0" +serde_json = "1.0" +serde_yaml = "0.8.16" + +regex = "1.4.3" +toml = "0.5" +uuid = { version = "0.8", features = ["serde", "v4"] } + +[dependencies.tera] +version = "1" +default-features = true + +[profile.release] +lto = true +codegen-units = 1 +opt-level = "z" + +# Uncomment to sacrifice Drop-on-panic cleanup and std::panic::catch_unwind +# for ~24K space saving +#panic = 'abort' diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 0000000..3add7e8 --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1,36 @@ +# Version 0.1 + +# Always nice to have a way to gather TODOs and FIXMEs quickly +report_todo = "Always" +report_fixme = "Always" + +# I was one of the proponents in the RFC discussion +use_try_shorthand = true + +# Try to wrestle rustfmt as close as possible to the style I habitually use +# and rigorously enforce by using `git gui` to only commit rustfmt changes +# I approve of. +brace_style = "PreferSameLine" +comment_width = 100 +enum_discrim_align_threshold = 10 +format_strings = true +fn_args_density = "Compressed" +fn_single_line = true +imports_indent = "Visual" +match_block_trailing_comma = true +normalize_doc_attributes = true +overflow_delimited_expr = true +reorder_impl_items = true +struct_field_align_threshold = 10 +use_field_init_shorthand = true +use_small_heuristics = "Max" +where_single_line = true +wrap_comments = false + +# I happen to like /* this */ for multi-line comments, thank you very much +normalize_comments = false + +# ----------------------------------------------------------------------------- + +# Used for debugging rustfmt configurations +#write_mode = "Diff" diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..c71725f --- /dev/null +++ b/src/main.rs @@ -0,0 +1,35 @@ +use clap::Parser; +use std::collections::HashMap; + +mod tera_lib; +use crate::tera_lib::{hash_from_data, data_templated}; + +#[derive(Parser, Debug)] +#[clap(author, version, about, long_about = None)] +struct Args { + /// Data file + #[clap(short, long)] + data: String, + + /// Template file + #[clap(short, long)] + tpl: String, + + /// Number of times to greet + #[clap(short, long, default_value_t = 1)] + count: u8, +} + +fn main() { + let args = Args::parse(); + let mut data_hash: HashMap = HashMap::new(); + let mut tpl_context = tera::Context::new(); + match hash_from_data(&args.data, &mut tpl_context, &mut data_hash, true) { + Ok(_) => + match data_templated(&"".to_string(),&args.tpl,&mut tpl_context, &data_hash) { + Ok(result) => println!("{}",result), + Err(e) => println!("Error with {} data in {} template: {}", args.data, args.tpl, e), + }, + Err(e) => println!("Error with {} data in {} template: {}", args.data, args.tpl, e), + } +} diff --git a/src/tera_lib.rs b/src/tera_lib.rs new file mode 100644 index 0000000..8f9f7ff --- /dev/null +++ b/src/tera_lib.rs @@ -0,0 +1,217 @@ +/*! Utility functions for variety of tasks */ +// +// Copyright 2020, Jesús Pérez Lorenzo + +use std::collections::HashMap; +use std::fs; +use std::path::Path; +use tera::{Tera}; + +/// make content from template path: from `root_path` + extension search for ".toml" or ".json" +/// template should be `root_path`.html and lang should be included in `root_path` +// #[must_use] +#[allow(clippy::implicit_hasher)] +#[allow(dead_code)] +pub fn make_template_content( + root_path: &str, + ctx: &mut tera::Context, + data_hash: &mut HashMap, + load_extend: bool, +) -> String { + let mut data_path = format!("{}.toml", &root_path); + if !Path::new(&data_path).exists() { + data_path = format!("{}.json", &root_path); + } + match hash_from_data(&data_path,ctx,data_hash,load_extend) { + Ok(_) => match data_templated( + "", + format!("{}.html", &root_path).as_str(), + ctx, + data_hash, + ) { + Ok(templated_file) => return templated_file, + Err(e) => println!( + "Error generating template {}.html: {}", + &root_path, e + ), + }, + Err(e) => println!( + "Error with data template {} - {} : {}", + &root_path, &data_path, e + ), + } + "".to_string() +} +/// `get_json_val` is a simple match Option to remove quotes in json values and returned as a String +#[must_use] +pub fn get_json_val(json_value: &serde_json::Value, dflt_val: String) -> String { + match json_value.as_str() { + Some(val) => val.to_string(), + None => dflt_val, + } +} +/// `get_toml_val` is a simple match Option to remove quotes in json values and returned as a String +#[must_use] +pub fn get_toml_val(toml_value: &toml::Value, dflt_val: String) -> String { + match toml_value.as_str() { + Some(val) => val.to_string(), + None => dflt_val, + } +} +/// `get_toml_val` is a simple match Option to remove quotes in json values and returned as a String +#[must_use] +pub fn get_yaml_val(yaml_value: &serde_yaml::Value, dflt_val: String) -> String { + match yaml_value.as_str() { + Some(val) => val.to_string(), + None => dflt_val, + } +} +/// Load a data file, fill a receive HASH, load template file and applied with Tera +/// By file extension is able to load data from JSON or TOML (as a table Value) +/// +/// Unwrap lines in the following example has to be changed to "matched" or ? with -> Result<> +///```rust +/// let mut data_hash: HashMap = HashMap::new(); +/// let path = String::from("resources/mail/test.json".to_string()); +/// let res = hash_from_data(&data_path, &mut data_hash).unwrap(); +/// let root_path = String::from("resources/mail"); +/// let tpl_result = data_templated(&root_path,"test.html",&res).unwrap(); +/// ``` +#[allow(clippy::missing_errors_doc,clippy::implicit_hasher)] +// +pub fn hash_from_data(path: &str, ctx: &mut tera::Context, data_hash: &mut HashMap, load_extend: bool) -> anyhow::Result<()> { + // {HashMap> { + let mut check_value = | key: String, v: String | { + if let Some(first_char) = v.chars().next() { + if first_char == '@' { + let field_file = &v[1..]; + let _ = hash_from_data(field_file, ctx, data_hash, load_extend); + // dbg!("{}",&data_hash); + return; + } + } + data_hash.insert(key, v); + }; + let vars_content = fs::read_to_string(&path)?; + //let mut data_hash: HashMap = HashMap::new(); + if let Some(extension) = path.split('.').last() { + //println!("File {} extension {}", &path, &extension); + match extension { + "json" => { + let data: HashMap = serde_json::from_str(&vars_content)?; + if load_extend { + match tera::Context::from_serialize(data) { + Ok(res) => { + ctx.extend(res); + }, + Err(e) => { + println!("Error loading {}: {}",&path, e); + }, + } + } else { + for (key, value) in data { + let val = get_json_val(&value, "".into()); + check_value(key,val); + } + } + } + "toml" => { + // As a table content + let data: toml::Value = toml::from_str(&vars_content)?; + // let data = &vars_content.parse::()?; + if load_extend { + match tera::Context::from_serialize(data) { + Ok(res) => { + ctx.extend(res); + }, + Err(e) => { + println!("Error loading {}: {}",&path, e); + }, + } + } else if let Some(table_data) = data.as_table() { + for (key, value) in table_data { + println!("-{}-{}",&key,&value); + let val = get_toml_val(&value, "".into()); + check_value(key.into(),val); + } + } + } + "yaml" => { + let data: HashMap = serde_yaml::from_str(&vars_content)?; + if load_extend { + match tera::Context::from_serialize(data) { + Ok(res) => { + ctx.extend(res); + }, + Err(e) => { + println!("Error loading {}: {}",&path, e); + }, + } + } else { + for (key, value) in data { + let val = get_yaml_val(&value, "".into()); + check_value(key,val); + } + } + } + _ => { + println!( + "File {} format extension {} not defined ", + &path, &extension + ); + } + } + } else { + println!("File {} unknown extension", &path); + } + // dbg!(&data_hash); + Ok(()) // data_hash) +} +/// Data tempalted create a Tera context form hashmap and reads a file template from path/template_name +/// Finally render to a String +#[allow(clippy::missing_errors_doc, clippy::implicit_hasher)] +pub fn data_templated( + path: &str, + template_name: &str, + tpl_context: &mut tera::Context, + content: &HashMap, +) -> anyhow::Result { + // let mut tpl_context = Context::new(); + for (key, value) in content.iter() { + tpl_context.insert(key, value); + } + let mut tera = Tera::default(); + + let template_head = "header.html"; + let tpl = read_path_file(&path, &template_name, "content")?; + let mut all_tpls = vec![("data-template.html",tpl)]; + match read_path_file(&path, &template_head, "content") { + Ok(tpl_head) => all_tpls.push((&template_head,tpl_head)), + Err(_) => {} // ignore if no header + } + tera.add_raw_templates(all_tpls)?; + let res = tera.render("data-template.html", &tpl_context)?; + Ok(res) +} +/// Read a `file_name` from a path (root / `file_name`) ( "" `file_name_full_path` ) +/// format of reading can be matched with `file_type` +/// TODO implement other types to read +#[allow(clippy::missing_errors_doc)] +pub fn read_path_file(path: &str, file_name: &str, file_type: &str) -> anyhow::Result { + let mut result = String::from(""); + let mut root_path = format!("{}/", path); + if root_path.as_str() == "/" { + root_path = String::from(""); + } + //println!("{}",format!("{}{}", &root_path.as_str(), &file_name)); + match file_type { + "content" => { + result = fs::read_to_string(format!("{}{}", &root_path.as_str(), &file_name).as_str())? + } + _ => println!( + "File {}{} type {} not defined ", + &root_path, &file_name, &file_type + ), + } + Ok(result) +}