Split Tera functions in several files
This commit is contained in:
parent
c728a8692b
commit
a97779567e
324
components/templates/src/global_fns/content.rs
Normal file
324
components/templates/src/global_fns/content.rs
Normal file
|
@ -0,0 +1,324 @@
|
|||
use library::{Library, Taxonomy};
|
||||
use std::collections::HashMap;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::{Arc, RwLock};
|
||||
use tera::{from_value, to_value, Function as TeraFn, Result, Value};
|
||||
use utils::slugs::{slugify_paths, SlugifyStrategy};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetTaxonomyUrl {
|
||||
taxonomies: HashMap<String, HashMap<String, String>>,
|
||||
default_lang: String,
|
||||
slugify: SlugifyStrategy,
|
||||
}
|
||||
|
||||
impl GetTaxonomyUrl {
|
||||
pub fn new(default_lang: &str, all_taxonomies: &[Taxonomy], slugify: SlugifyStrategy) -> Self {
|
||||
let mut taxonomies = HashMap::new();
|
||||
for taxo in all_taxonomies {
|
||||
let mut items = HashMap::new();
|
||||
for item in &taxo.items {
|
||||
items.insert(slugify_paths(&item.name.clone(), slugify), item.permalink.clone());
|
||||
}
|
||||
taxonomies.insert(format!("{}-{}", taxo.kind.name, taxo.lang), items);
|
||||
}
|
||||
Self { taxonomies, default_lang: default_lang.to_string(), slugify }
|
||||
}
|
||||
}
|
||||
impl TeraFn for GetTaxonomyUrl {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let kind = required_arg!(
|
||||
String,
|
||||
args.get("kind"),
|
||||
"`get_taxonomy_url` requires a `kind` argument with a string value"
|
||||
);
|
||||
let name = required_arg!(
|
||||
String,
|
||||
args.get("name"),
|
||||
"`get_taxonomy_url` requires a `name` argument with a string value"
|
||||
);
|
||||
let lang =
|
||||
optional_arg!(String, args.get("lang"), "`get_taxonomy`: `lang` must be a string")
|
||||
.unwrap_or_else(|| self.default_lang.clone());
|
||||
|
||||
let container = match self.taxonomies.get(&format!("{}-{}", kind, lang)) {
|
||||
Some(c) => c,
|
||||
None => {
|
||||
return Err(format!(
|
||||
"`get_taxonomy_url` received an unknown taxonomy as kind: {}",
|
||||
kind
|
||||
)
|
||||
.into());
|
||||
}
|
||||
};
|
||||
|
||||
if let Some(permalink) = container.get(&slugify_paths(&name, self.slugify)) {
|
||||
return Ok(to_value(permalink).unwrap());
|
||||
}
|
||||
|
||||
Err(format!("`get_taxonomy_url`: couldn't find `{}` in `{}` taxonomy", name, kind).into())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetPage {
|
||||
base_path: PathBuf,
|
||||
library: Arc<RwLock<Library>>,
|
||||
}
|
||||
impl GetPage {
|
||||
pub fn new(base_path: PathBuf, library: Arc<RwLock<Library>>) -> Self {
|
||||
Self { base_path: base_path.join("content"), library }
|
||||
}
|
||||
}
|
||||
impl TeraFn for GetPage {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let path = required_arg!(
|
||||
String,
|
||||
args.get("path"),
|
||||
"`get_page` requires a `path` argument with a string value"
|
||||
);
|
||||
let full_path = self.base_path.join(&path);
|
||||
let library = self.library.read().unwrap();
|
||||
match library.get_page(&full_path) {
|
||||
Some(p) => Ok(to_value(p.to_serialized(&library)).unwrap()),
|
||||
None => Err(format!("Page `{}` not found.", path).into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetSection {
|
||||
base_path: PathBuf,
|
||||
library: Arc<RwLock<Library>>,
|
||||
}
|
||||
impl GetSection {
|
||||
pub fn new(base_path: PathBuf, library: Arc<RwLock<Library>>) -> Self {
|
||||
Self { base_path: base_path.join("content"), library }
|
||||
}
|
||||
}
|
||||
impl TeraFn for GetSection {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let path = required_arg!(
|
||||
String,
|
||||
args.get("path"),
|
||||
"`get_section` requires a `path` argument with a string value"
|
||||
);
|
||||
|
||||
let metadata_only = args
|
||||
.get("metadata_only")
|
||||
.map_or(false, |c| from_value::<bool>(c.clone()).unwrap_or(false));
|
||||
|
||||
let full_path = self.base_path.join(&path);
|
||||
let library = self.library.read().unwrap();
|
||||
|
||||
match library.get_section(&full_path) {
|
||||
Some(s) => {
|
||||
if metadata_only {
|
||||
Ok(to_value(s.to_serialized_basic(&library)).unwrap())
|
||||
} else {
|
||||
Ok(to_value(s.to_serialized(&library)).unwrap())
|
||||
}
|
||||
}
|
||||
None => Err(format!("Section `{}` not found.", path).into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetTaxonomy {
|
||||
library: Arc<RwLock<Library>>,
|
||||
taxonomies: HashMap<String, Taxonomy>,
|
||||
default_lang: String,
|
||||
}
|
||||
impl GetTaxonomy {
|
||||
pub fn new(
|
||||
default_lang: &str,
|
||||
all_taxonomies: Vec<Taxonomy>,
|
||||
library: Arc<RwLock<Library>>,
|
||||
) -> Self {
|
||||
let mut taxonomies = HashMap::new();
|
||||
for taxo in all_taxonomies {
|
||||
taxonomies.insert(format!("{}-{}", taxo.kind.name, taxo.lang), taxo);
|
||||
}
|
||||
Self { taxonomies, library, default_lang: default_lang.to_string() }
|
||||
}
|
||||
}
|
||||
impl TeraFn for GetTaxonomy {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let kind = required_arg!(
|
||||
String,
|
||||
args.get("kind"),
|
||||
"`get_taxonomy` requires a `kind` argument with a string value"
|
||||
);
|
||||
|
||||
let lang =
|
||||
optional_arg!(String, args.get("lang"), "`get_taxonomy`: `lang` must be a string")
|
||||
.unwrap_or_else(|| self.default_lang.clone());
|
||||
|
||||
match self.taxonomies.get(&format!("{}-{}", kind, lang)) {
|
||||
Some(t) => Ok(to_value(t.to_serialized(&self.library.read().unwrap())).unwrap()),
|
||||
None => {
|
||||
Err(format!("`get_taxonomy` received an unknown taxonomy as kind: {}", kind).into())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use config::{Config, Taxonomy as TaxonomyConfig};
|
||||
use library::TaxonomyItem;
|
||||
|
||||
#[test]
|
||||
fn can_get_taxonomy() {
|
||||
let mut config = Config::default();
|
||||
config.slugify.taxonomies = SlugifyStrategy::On;
|
||||
let taxo_config = TaxonomyConfig { name: "tags".to_string(), ..TaxonomyConfig::default() };
|
||||
let taxo_config_fr =
|
||||
TaxonomyConfig { name: "tags".to_string(), ..TaxonomyConfig::default() };
|
||||
let library = Arc::new(RwLock::new(Library::new(0, 0, false)));
|
||||
let tag = TaxonomyItem::new(
|
||||
"Programming",
|
||||
&config.default_language,
|
||||
"tags",
|
||||
&config,
|
||||
vec![],
|
||||
&library.read().unwrap(),
|
||||
);
|
||||
let tag_fr = TaxonomyItem::new(
|
||||
"Programmation",
|
||||
"fr",
|
||||
"tags",
|
||||
&config,
|
||||
vec![],
|
||||
&library.read().unwrap(),
|
||||
);
|
||||
let tags = Taxonomy {
|
||||
kind: taxo_config,
|
||||
lang: config.default_language.clone(),
|
||||
slug: "tags".to_string(),
|
||||
items: vec![tag],
|
||||
};
|
||||
let tags_fr = Taxonomy {
|
||||
kind: taxo_config_fr,
|
||||
lang: "fr".to_owned(),
|
||||
slug: "tags".to_string(),
|
||||
items: vec![tag_fr],
|
||||
};
|
||||
|
||||
let taxonomies = vec![tags.clone(), tags_fr.clone()];
|
||||
let static_fn =
|
||||
GetTaxonomy::new(&config.default_language, taxonomies.clone(), library.clone());
|
||||
// can find it correctly
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
let res = static_fn.call(&args).unwrap();
|
||||
let res_obj = res.as_object().unwrap();
|
||||
assert_eq!(res_obj["kind"], to_value(tags.kind).unwrap());
|
||||
assert_eq!(res_obj["items"].clone().as_array().unwrap().len(), 1);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()["name"],
|
||||
Value::String("Programming".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()["slug"],
|
||||
Value::String("programming".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()
|
||||
["permalink"],
|
||||
Value::String("http://a-website.com/tags/programming/".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()["pages"],
|
||||
Value::Array(vec![])
|
||||
);
|
||||
// Works with other languages as well
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("lang".to_string(), to_value("fr").unwrap());
|
||||
let res = static_fn.call(&args).unwrap();
|
||||
let res_obj = res.as_object().unwrap();
|
||||
assert_eq!(res_obj["kind"], to_value(tags_fr.kind).unwrap());
|
||||
assert_eq!(res_obj["items"].clone().as_array().unwrap().len(), 1);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()["name"],
|
||||
Value::String("Programmation".to_string())
|
||||
);
|
||||
|
||||
// and errors if it can't find it
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("something-else").unwrap());
|
||||
assert!(static_fn.call(&args).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_get_taxonomy_url() {
|
||||
let mut config = Config::default();
|
||||
config.slugify.taxonomies = SlugifyStrategy::On;
|
||||
let taxo_config = TaxonomyConfig { name: "tags".to_string(), ..TaxonomyConfig::default() };
|
||||
let taxo_config_fr =
|
||||
TaxonomyConfig { name: "tags".to_string(), ..TaxonomyConfig::default() };
|
||||
let library = Library::new(0, 0, false);
|
||||
let tag = TaxonomyItem::new(
|
||||
"Programming",
|
||||
&config.default_language,
|
||||
"tags",
|
||||
&config,
|
||||
vec![],
|
||||
&library,
|
||||
);
|
||||
let tag_fr = TaxonomyItem::new("Programmation", "fr", "tags", &config, vec![], &library);
|
||||
let tags = Taxonomy {
|
||||
kind: taxo_config,
|
||||
lang: config.default_language.clone(),
|
||||
slug: "tags".to_string(),
|
||||
items: vec![tag],
|
||||
};
|
||||
let tags_fr = Taxonomy {
|
||||
kind: taxo_config_fr,
|
||||
lang: "fr".to_owned(),
|
||||
slug: "tags".to_string(),
|
||||
items: vec![tag_fr],
|
||||
};
|
||||
|
||||
let taxonomies = vec![tags.clone(), tags_fr.clone()];
|
||||
let static_fn =
|
||||
GetTaxonomyUrl::new(&config.default_language, &taxonomies, config.slugify.taxonomies);
|
||||
|
||||
// can find it correctly
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("name".to_string(), to_value("Programming").unwrap());
|
||||
assert_eq!(
|
||||
static_fn.call(&args).unwrap(),
|
||||
to_value("http://a-website.com/tags/programming/").unwrap()
|
||||
);
|
||||
|
||||
// can find it correctly with inconsistent capitalisation
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("name".to_string(), to_value("programming").unwrap());
|
||||
assert_eq!(
|
||||
static_fn.call(&args).unwrap(),
|
||||
to_value("http://a-website.com/tags/programming/").unwrap()
|
||||
);
|
||||
|
||||
// works with other languages
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("name".to_string(), to_value("Programmation").unwrap());
|
||||
args.insert("lang".to_string(), to_value("fr").unwrap());
|
||||
assert_eq!(
|
||||
static_fn.call(&args).unwrap(),
|
||||
to_value("http://a-website.com/fr/tags/programmation/").unwrap()
|
||||
);
|
||||
|
||||
// and errors if it can't find it
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("name".to_string(), to_value("random").unwrap());
|
||||
assert!(static_fn.call(&args).is_err());
|
||||
}
|
||||
}
|
120
components/templates/src/global_fns/images.rs
Normal file
120
components/templates/src/global_fns/images.rs
Normal file
|
@ -0,0 +1,120 @@
|
|||
use std::collections::HashMap;
|
||||
use std::ffi::OsStr;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use image::GenericImageView;
|
||||
use svg_metadata as svg;
|
||||
use tera::{from_value, to_value, Error, Function as TeraFn, Result, Value};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct ResizeImage {
|
||||
imageproc: Arc<Mutex<imageproc::Processor>>,
|
||||
}
|
||||
impl ResizeImage {
|
||||
pub fn new(imageproc: Arc<Mutex<imageproc::Processor>>) -> Self {
|
||||
Self { imageproc }
|
||||
}
|
||||
}
|
||||
|
||||
static DEFAULT_OP: &str = "fill";
|
||||
static DEFAULT_FMT: &str = "auto";
|
||||
|
||||
impl TeraFn for ResizeImage {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let path = required_arg!(
|
||||
String,
|
||||
args.get("path"),
|
||||
"`resize_image` requires a `path` argument with a string value"
|
||||
);
|
||||
let width = optional_arg!(
|
||||
u32,
|
||||
args.get("width"),
|
||||
"`resize_image`: `width` must be a non-negative integer"
|
||||
);
|
||||
let height = optional_arg!(
|
||||
u32,
|
||||
args.get("height"),
|
||||
"`resize_image`: `height` must be a non-negative integer"
|
||||
);
|
||||
let op = optional_arg!(String, args.get("op"), "`resize_image`: `op` must be a string")
|
||||
.unwrap_or_else(|| DEFAULT_OP.to_string());
|
||||
|
||||
let format =
|
||||
optional_arg!(String, args.get("format"), "`resize_image`: `format` must be a string")
|
||||
.unwrap_or_else(|| DEFAULT_FMT.to_string());
|
||||
|
||||
let quality =
|
||||
optional_arg!(u8, args.get("quality"), "`resize_image`: `quality` must be a number");
|
||||
if let Some(quality) = quality {
|
||||
if quality == 0 || quality > 100 {
|
||||
return Err("`resize_image`: `quality` must be in range 1-100".to_string().into());
|
||||
}
|
||||
}
|
||||
|
||||
let mut imageproc = self.imageproc.lock().unwrap();
|
||||
if !imageproc.source_exists(&path) {
|
||||
return Err(format!("`resize_image`: Cannot find path: {}", path).into());
|
||||
}
|
||||
|
||||
let imageop = imageproc::ImageOp::from_args(path, &op, width, height, &format, quality)
|
||||
.map_err(|e| format!("`resize_image`: {}", e))?;
|
||||
let url = imageproc.insert(imageop);
|
||||
|
||||
to_value(url).map_err(|err| err.into())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetImageMeta {
|
||||
content_path: PathBuf,
|
||||
}
|
||||
|
||||
impl GetImageMeta {
|
||||
pub fn new(content_path: PathBuf) -> Self {
|
||||
Self { content_path }
|
||||
}
|
||||
}
|
||||
|
||||
impl TeraFn for GetImageMeta {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let path = required_arg!(
|
||||
String,
|
||||
args.get("path"),
|
||||
"`get_image_metadata` requires a `path` argument with a string value"
|
||||
);
|
||||
let src_path = self.content_path.join(&path);
|
||||
if !src_path.exists() {
|
||||
return Err(format!("`get_image_metadata`: Cannot find path: {}", path).into());
|
||||
}
|
||||
let (height, width) = image_dimensions(&src_path)?;
|
||||
let mut map = tera::Map::new();
|
||||
map.insert(String::from("height"), Value::Number(tera::Number::from(height)));
|
||||
map.insert(String::from("width"), Value::Number(tera::Number::from(width)));
|
||||
Ok(Value::Object(map))
|
||||
}
|
||||
}
|
||||
|
||||
// Try to read the image dimensions for a given image
|
||||
fn image_dimensions(path: &PathBuf) -> Result<(u32, u32)> {
|
||||
if let Some("svg") = path.extension().and_then(OsStr::to_str) {
|
||||
let img = svg::Metadata::parse_file(&path)
|
||||
.map_err(|e| Error::chain(format!("Failed to process SVG: {}", path.display()), e))?;
|
||||
match (img.height(), img.width(), img.view_box()) {
|
||||
(Some(h), Some(w), _) => Ok((h as u32, w as u32)),
|
||||
(_, _, Some(view_box)) => Ok((view_box.height as u32, view_box.width as u32)),
|
||||
_ => Err("Invalid dimensions: SVG width/height and viewbox not set.".into()),
|
||||
}
|
||||
} else {
|
||||
let img = image::open(&path)
|
||||
.map_err(|e| Error::chain(format!("Failed to process image: {}", path.display()), e))?;
|
||||
Ok((img.height(), img.width()))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// TODO
|
||||
}
|
|
@ -1,25 +1,23 @@
|
|||
use std::collections::HashMap;
|
||||
use std::ffi::OsStr;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::{Arc, Mutex, RwLock};
|
||||
use std::{fs, io, result};
|
||||
|
||||
use base64::encode as encode_b64;
|
||||
use sha2::{digest, Sha256, Sha384, Sha512};
|
||||
use svg_metadata as svg;
|
||||
use tera::{from_value, to_value, Error, Function as TeraFn, Result, Value};
|
||||
|
||||
use config::Config;
|
||||
use image::GenericImageView;
|
||||
use library::{Library, Taxonomy};
|
||||
use utils::site::resolve_internal_link;
|
||||
use utils::slugs::{slugify_paths, SlugifyStrategy};
|
||||
|
||||
#[macro_use]
|
||||
mod macros;
|
||||
|
||||
mod content;
|
||||
mod images;
|
||||
mod load_data;
|
||||
|
||||
pub use self::content::{GetPage, GetSection, GetTaxonomy, GetTaxonomyUrl};
|
||||
pub use self::images::{GetImageMeta, ResizeImage};
|
||||
pub use self::load_data::LoadData;
|
||||
|
||||
#[derive(Debug)]
|
||||
|
@ -238,270 +236,6 @@ impl TeraFn for GetFileHash {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct ResizeImage {
|
||||
imageproc: Arc<Mutex<imageproc::Processor>>,
|
||||
}
|
||||
impl ResizeImage {
|
||||
pub fn new(imageproc: Arc<Mutex<imageproc::Processor>>) -> Self {
|
||||
Self { imageproc }
|
||||
}
|
||||
}
|
||||
|
||||
static DEFAULT_OP: &str = "fill";
|
||||
static DEFAULT_FMT: &str = "auto";
|
||||
|
||||
impl TeraFn for ResizeImage {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let path = required_arg!(
|
||||
String,
|
||||
args.get("path"),
|
||||
"`resize_image` requires a `path` argument with a string value"
|
||||
);
|
||||
let width = optional_arg!(
|
||||
u32,
|
||||
args.get("width"),
|
||||
"`resize_image`: `width` must be a non-negative integer"
|
||||
);
|
||||
let height = optional_arg!(
|
||||
u32,
|
||||
args.get("height"),
|
||||
"`resize_image`: `height` must be a non-negative integer"
|
||||
);
|
||||
let op = optional_arg!(String, args.get("op"), "`resize_image`: `op` must be a string")
|
||||
.unwrap_or_else(|| DEFAULT_OP.to_string());
|
||||
|
||||
let format =
|
||||
optional_arg!(String, args.get("format"), "`resize_image`: `format` must be a string")
|
||||
.unwrap_or_else(|| DEFAULT_FMT.to_string());
|
||||
|
||||
let quality =
|
||||
optional_arg!(u8, args.get("quality"), "`resize_image`: `quality` must be a number");
|
||||
if let Some(quality) = quality {
|
||||
if quality == 0 || quality > 100 {
|
||||
return Err("`resize_image`: `quality` must be in range 1-100".to_string().into());
|
||||
}
|
||||
}
|
||||
|
||||
let mut imageproc = self.imageproc.lock().unwrap();
|
||||
if !imageproc.source_exists(&path) {
|
||||
return Err(format!("`resize_image`: Cannot find path: {}", path).into());
|
||||
}
|
||||
|
||||
let imageop = imageproc::ImageOp::from_args(path, &op, width, height, &format, quality)
|
||||
.map_err(|e| format!("`resize_image`: {}", e))?;
|
||||
let url = imageproc.insert(imageop);
|
||||
|
||||
to_value(url).map_err(|err| err.into())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetImageMeta {
|
||||
content_path: PathBuf,
|
||||
}
|
||||
|
||||
impl GetImageMeta {
|
||||
pub fn new(content_path: PathBuf) -> Self {
|
||||
Self { content_path }
|
||||
}
|
||||
}
|
||||
|
||||
impl TeraFn for GetImageMeta {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let path = required_arg!(
|
||||
String,
|
||||
args.get("path"),
|
||||
"`get_image_metadata` requires a `path` argument with a string value"
|
||||
);
|
||||
let src_path = self.content_path.join(&path);
|
||||
if !src_path.exists() {
|
||||
return Err(format!("`get_image_metadata`: Cannot find path: {}", path).into());
|
||||
}
|
||||
let (height, width) = image_dimensions(&src_path)?;
|
||||
let mut map = tera::Map::new();
|
||||
map.insert(String::from("height"), Value::Number(tera::Number::from(height)));
|
||||
map.insert(String::from("width"), Value::Number(tera::Number::from(width)));
|
||||
Ok(Value::Object(map))
|
||||
}
|
||||
}
|
||||
|
||||
// Try to read the image dimensions for a given image
|
||||
fn image_dimensions(path: &PathBuf) -> Result<(u32, u32)> {
|
||||
if let Some("svg") = path.extension().and_then(OsStr::to_str) {
|
||||
let img = svg::Metadata::parse_file(&path)
|
||||
.map_err(|e| Error::chain(format!("Failed to process SVG: {}", path.display()), e))?;
|
||||
match (img.height(), img.width(), img.view_box()) {
|
||||
(Some(h), Some(w), _) => Ok((h as u32, w as u32)),
|
||||
(_, _, Some(view_box)) => Ok((view_box.height as u32, view_box.width as u32)),
|
||||
_ => Err("Invalid dimensions: SVG width/height and viewbox not set.".into()),
|
||||
}
|
||||
} else {
|
||||
let img = image::open(&path)
|
||||
.map_err(|e| Error::chain(format!("Failed to process image: {}", path.display()), e))?;
|
||||
Ok((img.height(), img.width()))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetTaxonomyUrl {
|
||||
taxonomies: HashMap<String, HashMap<String, String>>,
|
||||
default_lang: String,
|
||||
slugify: SlugifyStrategy,
|
||||
}
|
||||
|
||||
impl GetTaxonomyUrl {
|
||||
pub fn new(default_lang: &str, all_taxonomies: &[Taxonomy], slugify: SlugifyStrategy) -> Self {
|
||||
let mut taxonomies = HashMap::new();
|
||||
for taxo in all_taxonomies {
|
||||
let mut items = HashMap::new();
|
||||
for item in &taxo.items {
|
||||
items.insert(slugify_paths(&item.name.clone(), slugify), item.permalink.clone());
|
||||
}
|
||||
taxonomies.insert(format!("{}-{}", taxo.kind.name, taxo.lang), items);
|
||||
}
|
||||
Self { taxonomies, default_lang: default_lang.to_string(), slugify }
|
||||
}
|
||||
}
|
||||
impl TeraFn for GetTaxonomyUrl {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let kind = required_arg!(
|
||||
String,
|
||||
args.get("kind"),
|
||||
"`get_taxonomy_url` requires a `kind` argument with a string value"
|
||||
);
|
||||
let name = required_arg!(
|
||||
String,
|
||||
args.get("name"),
|
||||
"`get_taxonomy_url` requires a `name` argument with a string value"
|
||||
);
|
||||
let lang =
|
||||
optional_arg!(String, args.get("lang"), "`get_taxonomy`: `lang` must be a string")
|
||||
.unwrap_or_else(|| self.default_lang.clone());
|
||||
|
||||
let container = match self.taxonomies.get(&format!("{}-{}", kind, lang)) {
|
||||
Some(c) => c,
|
||||
None => {
|
||||
return Err(format!(
|
||||
"`get_taxonomy_url` received an unknown taxonomy as kind: {}",
|
||||
kind
|
||||
)
|
||||
.into());
|
||||
}
|
||||
};
|
||||
|
||||
if let Some(permalink) = container.get(&slugify_paths(&name, self.slugify)) {
|
||||
return Ok(to_value(permalink).unwrap());
|
||||
}
|
||||
|
||||
Err(format!("`get_taxonomy_url`: couldn't find `{}` in `{}` taxonomy", name, kind).into())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetPage {
|
||||
base_path: PathBuf,
|
||||
library: Arc<RwLock<Library>>,
|
||||
}
|
||||
impl GetPage {
|
||||
pub fn new(base_path: PathBuf, library: Arc<RwLock<Library>>) -> Self {
|
||||
Self { base_path: base_path.join("content"), library }
|
||||
}
|
||||
}
|
||||
impl TeraFn for GetPage {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let path = required_arg!(
|
||||
String,
|
||||
args.get("path"),
|
||||
"`get_page` requires a `path` argument with a string value"
|
||||
);
|
||||
let full_path = self.base_path.join(&path);
|
||||
let library = self.library.read().unwrap();
|
||||
match library.get_page(&full_path) {
|
||||
Some(p) => Ok(to_value(p.to_serialized(&library)).unwrap()),
|
||||
None => Err(format!("Page `{}` not found.", path).into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetSection {
|
||||
base_path: PathBuf,
|
||||
library: Arc<RwLock<Library>>,
|
||||
}
|
||||
impl GetSection {
|
||||
pub fn new(base_path: PathBuf, library: Arc<RwLock<Library>>) -> Self {
|
||||
Self { base_path: base_path.join("content"), library }
|
||||
}
|
||||
}
|
||||
impl TeraFn for GetSection {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let path = required_arg!(
|
||||
String,
|
||||
args.get("path"),
|
||||
"`get_section` requires a `path` argument with a string value"
|
||||
);
|
||||
|
||||
let metadata_only = args
|
||||
.get("metadata_only")
|
||||
.map_or(false, |c| from_value::<bool>(c.clone()).unwrap_or(false));
|
||||
|
||||
let full_path = self.base_path.join(&path);
|
||||
let library = self.library.read().unwrap();
|
||||
|
||||
match library.get_section(&full_path) {
|
||||
Some(s) => {
|
||||
if metadata_only {
|
||||
Ok(to_value(s.to_serialized_basic(&library)).unwrap())
|
||||
} else {
|
||||
Ok(to_value(s.to_serialized(&library)).unwrap())
|
||||
}
|
||||
}
|
||||
None => Err(format!("Section `{}` not found.", path).into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct GetTaxonomy {
|
||||
library: Arc<RwLock<Library>>,
|
||||
taxonomies: HashMap<String, Taxonomy>,
|
||||
default_lang: String,
|
||||
}
|
||||
impl GetTaxonomy {
|
||||
pub fn new(
|
||||
default_lang: &str,
|
||||
all_taxonomies: Vec<Taxonomy>,
|
||||
library: Arc<RwLock<Library>>,
|
||||
) -> Self {
|
||||
let mut taxonomies = HashMap::new();
|
||||
for taxo in all_taxonomies {
|
||||
taxonomies.insert(format!("{}-{}", taxo.kind.name, taxo.lang), taxo);
|
||||
}
|
||||
Self { taxonomies, library, default_lang: default_lang.to_string() }
|
||||
}
|
||||
}
|
||||
impl TeraFn for GetTaxonomy {
|
||||
fn call(&self, args: &HashMap<String, Value>) -> Result<Value> {
|
||||
let kind = required_arg!(
|
||||
String,
|
||||
args.get("kind"),
|
||||
"`get_taxonomy` requires a `kind` argument with a string value"
|
||||
);
|
||||
|
||||
let lang =
|
||||
optional_arg!(String, args.get("lang"), "`get_taxonomy`: `lang` must be a string")
|
||||
.unwrap_or_else(|| self.default_lang.clone());
|
||||
|
||||
match self.taxonomies.get(&format!("{}-{}", kind, lang)) {
|
||||
Some(t) => Ok(to_value(t.to_serialized(&self.library.read().unwrap())).unwrap()),
|
||||
None => {
|
||||
Err(format!("`get_taxonomy` received an unknown taxonomy as kind: {}", kind).into())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{GetFileHash, GetTaxonomy, GetTaxonomyUrl, GetUrl, Trans};
|
||||
|
@ -583,158 +317,6 @@ mod tests {
|
|||
assert_eq!(static_fn.call(&args).unwrap(), "http://a-website.com/app.css");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_get_taxonomy() {
|
||||
let mut config = Config::default();
|
||||
config.slugify.taxonomies = SlugifyStrategy::On;
|
||||
let taxo_config = TaxonomyConfig { name: "tags".to_string(), ..TaxonomyConfig::default() };
|
||||
let taxo_config_fr =
|
||||
TaxonomyConfig { name: "tags".to_string(), ..TaxonomyConfig::default() };
|
||||
let library = Arc::new(RwLock::new(Library::new(0, 0, false)));
|
||||
let tag = TaxonomyItem::new(
|
||||
"Programming",
|
||||
&config.default_language,
|
||||
"tags",
|
||||
&config,
|
||||
vec![],
|
||||
&library.read().unwrap(),
|
||||
);
|
||||
let tag_fr = TaxonomyItem::new(
|
||||
"Programmation",
|
||||
"fr",
|
||||
"tags",
|
||||
&config,
|
||||
vec![],
|
||||
&library.read().unwrap(),
|
||||
);
|
||||
let tags = Taxonomy {
|
||||
kind: taxo_config,
|
||||
lang: config.default_language.clone(),
|
||||
slug: "tags".to_string(),
|
||||
items: vec![tag],
|
||||
};
|
||||
let tags_fr = Taxonomy {
|
||||
kind: taxo_config_fr,
|
||||
lang: "fr".to_owned(),
|
||||
slug: "tags".to_string(),
|
||||
items: vec![tag_fr],
|
||||
};
|
||||
|
||||
let taxonomies = vec![tags.clone(), tags_fr.clone()];
|
||||
let static_fn =
|
||||
GetTaxonomy::new(&config.default_language, taxonomies.clone(), library.clone());
|
||||
// can find it correctly
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
let res = static_fn.call(&args).unwrap();
|
||||
let res_obj = res.as_object().unwrap();
|
||||
assert_eq!(res_obj["kind"], to_value(tags.kind).unwrap());
|
||||
assert_eq!(res_obj["items"].clone().as_array().unwrap().len(), 1);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()["name"],
|
||||
Value::String("Programming".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()["slug"],
|
||||
Value::String("programming".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()
|
||||
["permalink"],
|
||||
Value::String("http://a-website.com/tags/programming/".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()["pages"],
|
||||
Value::Array(vec![])
|
||||
);
|
||||
// Works with other languages as well
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("lang".to_string(), to_value("fr").unwrap());
|
||||
let res = static_fn.call(&args).unwrap();
|
||||
let res_obj = res.as_object().unwrap();
|
||||
assert_eq!(res_obj["kind"], to_value(tags_fr.kind).unwrap());
|
||||
assert_eq!(res_obj["items"].clone().as_array().unwrap().len(), 1);
|
||||
assert_eq!(
|
||||
res_obj["items"].clone().as_array().unwrap()[0].clone().as_object().unwrap()["name"],
|
||||
Value::String("Programmation".to_string())
|
||||
);
|
||||
|
||||
// and errors if it can't find it
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("something-else").unwrap());
|
||||
assert!(static_fn.call(&args).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_get_taxonomy_url() {
|
||||
let mut config = Config::default();
|
||||
config.slugify.taxonomies = SlugifyStrategy::On;
|
||||
let taxo_config = TaxonomyConfig { name: "tags".to_string(), ..TaxonomyConfig::default() };
|
||||
let taxo_config_fr =
|
||||
TaxonomyConfig { name: "tags".to_string(), ..TaxonomyConfig::default() };
|
||||
let library = Library::new(0, 0, false);
|
||||
let tag = TaxonomyItem::new(
|
||||
"Programming",
|
||||
&config.default_language,
|
||||
"tags",
|
||||
&config,
|
||||
vec![],
|
||||
&library,
|
||||
);
|
||||
let tag_fr = TaxonomyItem::new("Programmation", "fr", "tags", &config, vec![], &library);
|
||||
let tags = Taxonomy {
|
||||
kind: taxo_config,
|
||||
lang: config.default_language.clone(),
|
||||
slug: "tags".to_string(),
|
||||
items: vec![tag],
|
||||
};
|
||||
let tags_fr = Taxonomy {
|
||||
kind: taxo_config_fr,
|
||||
lang: "fr".to_owned(),
|
||||
slug: "tags".to_string(),
|
||||
items: vec![tag_fr],
|
||||
};
|
||||
|
||||
let taxonomies = vec![tags.clone(), tags_fr.clone()];
|
||||
let static_fn =
|
||||
GetTaxonomyUrl::new(&config.default_language, &taxonomies, config.slugify.taxonomies);
|
||||
|
||||
// can find it correctly
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("name".to_string(), to_value("Programming").unwrap());
|
||||
assert_eq!(
|
||||
static_fn.call(&args).unwrap(),
|
||||
to_value("http://a-website.com/tags/programming/").unwrap()
|
||||
);
|
||||
|
||||
// can find it correctly with inconsistent capitalisation
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("name".to_string(), to_value("programming").unwrap());
|
||||
assert_eq!(
|
||||
static_fn.call(&args).unwrap(),
|
||||
to_value("http://a-website.com/tags/programming/").unwrap()
|
||||
);
|
||||
|
||||
// works with other languages
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("name".to_string(), to_value("Programmation").unwrap());
|
||||
args.insert("lang".to_string(), to_value("fr").unwrap());
|
||||
assert_eq!(
|
||||
static_fn.call(&args).unwrap(),
|
||||
to_value("http://a-website.com/fr/tags/programmation/").unwrap()
|
||||
);
|
||||
|
||||
// and errors if it can't find it
|
||||
let mut args = HashMap::new();
|
||||
args.insert("kind".to_string(), to_value("tags").unwrap());
|
||||
args.insert("name".to_string(), to_value("random").unwrap());
|
||||
assert!(static_fn.call(&args).is_err());
|
||||
}
|
||||
|
||||
const TRANS_CONFIG: &str = r#"
|
||||
base_url = "https://remplace-par-ton-url.fr"
|
||||
default_language = "fr"
|
||||
|
|
Loading…
Reference in a new issue