Add default template warning

CHANGELOG.md

@@ -1,5 +1,7 @@
 # Changelog
 
+## 0.18.0 (unreleased)
+
 ## 0.17.2 (2023-03-19)
 
 - Fix one more invalid error with colocated directories

components/link_checker/src/lib.rs

@@ -30,6 +30,13 @@ pub fn message(res: &Result) -> String {
 // Keep history of link checks so a rebuild doesn't have to check again
 static LINKS: Lazy<Arc<RwLock<HashMap<String, Result>>>> =
  Lazy::new(|| Arc::new(RwLock::new(HashMap::new())));
+// Make sure to create only a single Client so that we can reuse the connections
+static CLIENT: Lazy<Client> = Lazy::new(|| {
+ Client::builder()
+ .user_agent(concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION")))
+ .build()
+ .expect("reqwest client build")
+});
 
 pub fn check_url(url: &str, config: &LinkChecker) -> Result {
  {
@@ -44,15 +51,11 @@ pub fn check_url(url: &str, config: &LinkChecker) -> Result {
  headers.append(ACCEPT, "*/*".parse().unwrap());
 
  // TODO: pass the client to the check_url, do not pass the config
- let client = Client::builder()
- .user_agent(concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION")))
- .build()
- .expect("reqwest client build");
 
  let check_anchor = !config.skip_anchor_prefixes.iter().any(|prefix| url.starts_with(prefix));
 
  // Need to actually do the link checking
- let res = match client.get(url).headers(headers).send() {
+ let res = match CLIENT.get(url).headers(headers).send() {
  Ok(ref mut response) if check_anchor && has_anchor(url) => {
  let body = {
  let mut buf: Vec<u8> = vec![];

components/site/src/lib.rs

@@ -26,7 +26,7 @@ use utils::fs::{
  ensure_directory_exists,
 };
 use utils::net::{get_available_port, is_external_link};
-use utils::templates::{render_template, ShortcodeDefinition};
+use utils::templates::{is_default_template, render_template, ShortcodeDefinition};
 use utils::types::InsertAnchor;
 
 pub static SITE_CONTENT: Lazy<Arc<RwLock<HashMap<RelativePathBuf, String>>>> =
@@ -362,6 +362,40 @@ impl Site {
  Ok(())
  }
 
+ /// Gather all sites and pages which were rendered with a default template.
+ /// We can later warn the user about possible unexpected defaults.
+ pub fn get_default_templates(&self) -> Result<Vec<String>> {
+ let lib = self.library.read().unwrap();
+ let pages = &lib.pages;
+ let sections = &lib.sections;
+ let mut result: Vec<String> = Vec::with_capacity(pages.len() + sections.len());
+ for (path, page) in pages.iter() {
+ let name;
+ let default_name = "page.html".to_owned();
+ if let Some(template) = &page.meta.template {
+ name = template;
+ } else {
+ name = &default_name;
+ }
+ if is_default_template(name, &self.tera, &self.config.theme)? {
+ result.push(path.display().to_string());
+ }
+ }
+ for (path, section) in sections.iter() {
+ let name;
+ let default_name = "section.html".to_owned();
+ if let Some(template) = &section.meta.template {
+ name = template;
+ } else {
+ name = &default_name;
+ }
+ if is_default_template(name, &self.tera, &self.config.theme)? {
+ result.push(path.display().to_string());
+ }
+ }
+ Ok(result)
+ }
+
  /// Insert a default index section for each language if necessary so we don't need to create
  /// a _index.md to render the index page at the root of the site
  pub fn create_default_index_sections(&mut self) -> Result<()> {

components/templates/src/builtins/atom.xml

@@ -40,7 +40,7 @@
  {% if page.summary %}
  <summary type="html">{{ page.summary }}</summary>
  {% else %}
- <content type="html">{{ page.content }}</content>
+ <content type="html" xml:base="{{ page.permalink | escape_xml | safe }}">{{ page.content }}</content>
  {% endif %}
  </entry>
  {%- endfor %}

components/templates/src/builtins/rss.xml

@@ -33,7 +33,7 @@
  </author>
  <link>{{ page.permalink | escape_xml | safe }}</link>
  <guid>{{ page.permalink | escape_xml | safe }}</guid>
- <description>{% if page.summary %}{{ page.summary }}{% else %}{{ page.content }}{% endif %}</description>
+ <description xml:base="{{ page.permalink | escape_xml | safe }}">{% if page.summary %}{{ page.summary }}{% else %}{{ page.content }}{% endif %}</description>
  </item>
  {%- endfor %}
  </channel>

components/templates/src/filters.rs

@@ -1,9 +1,12 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::hash::BuildHasher;
+use std::sync::{Arc, Mutex};
 
 use config::Config;
+
 use libs::base64::engine::{general_purpose::STANDARD as standard_b64, Engine};
+use libs::regex::Regex;
 use libs::tera::{
  to_value, try_get_value, Error as TeraError, Filter as TeraFilter, Result as TeraResult, Tera,
  Value,
@@ -78,6 +81,53 @@ pub fn base64_decode<S: BuildHasher>(
  Ok(to_value(as_str).unwrap())
 }
 
+#[derive(Debug)]
+pub struct RegexReplaceFilter {
+ re_cache: Arc<Mutex<HashMap<String, Regex>>>,
+}
+
+impl RegexReplaceFilter {
+ pub fn new() -> Self {
+ return Self { re_cache: Arc::new(Mutex::new(HashMap::new())) };
+ }
+}
+
+impl TeraFilter for RegexReplaceFilter {
+ fn filter(&self, value: &Value, args: &HashMap<String, Value>) -> TeraResult<Value> {
+ let text = try_get_value!("regex_replace", "value", String, value);
+ let pattern = match args.get("pattern") {
+ Some(val) => try_get_value!("regex_replace", "pattern", String, val),
+ None => {
+ return Err(TeraError::msg(
+ "Filter `regex_replace` expected an arg called `pattern`",
+ ))
+ }
+ };
+ let rep = match args.get("rep") {
+ Some(val) => try_get_value!("regex_replace", "rep", String, val),
+ None => {
+ return Err(TeraError::msg("Filter `regex_replace` expected an arg called `rep`"))
+ }
+ };
+
+ let mut cache = self.re_cache.lock().expect("re_cache lock");
+ let replaced = {
+ match cache.get(&pattern) {
+ Some(pat) => pat.replace_all(&text, &rep),
+ None => {
+ let pat = Regex::new(&pattern)
+ .map_err(|e| format!("`regex_replace`: failed to compile regex: {}", e))?;
+ let replaced = pat.replace_all(&text, &rep);
+ cache.insert(pattern, pat);
+ replaced
+ }
+ }
+ };
+
+ Ok(to_value(replaced).unwrap())
+ }
+}
+
 #[derive(Debug)]
 pub struct NumFormatFilter {
  default_language: String,
@@ -114,7 +164,9 @@ mod tests {
 
  use libs::tera::{to_value, Filter, Tera};
 
- use super::{base64_decode, base64_encode, MarkdownFilter, NumFormatFilter};
+ use super::{
+ base64_decode, base64_encode, MarkdownFilter, NumFormatFilter, RegexReplaceFilter,
+ };
  use config::Config;
 
  #[test]
@@ -251,6 +303,22 @@ mod tests {
  }
  }
 
+ #[test]
+ fn regex_replace_filter() {
+ let value = "Springsteen, Bruce";
+ let expected = "Bruce Springsteen";
+ let pattern = r"(?P<last>[^,\s]+),\s+(?P<first>\S+)";
+ let rep = "$first $last";
+ let mut args = HashMap::new();
+ args.insert("pattern".to_string(), to_value(pattern).unwrap());
+ args.insert("rep".to_string(), to_value(rep).unwrap());
+ let regex_replace = RegexReplaceFilter::new();
+ let result = regex_replace.filter(&to_value(value).unwrap(), &args);
+ assert!(result.is_ok());
+ assert_eq!(result.unwrap(), to_value(expected).unwrap());
+ assert!(regex_replace.re_cache.lock().unwrap().contains_key(pattern));
+ }
+
  #[test]
  fn num_format_filter() {
  let tests = vec![

components/templates/src/lib.rs

@@ -28,6 +28,7 @@ pub static ZOLA_TERA: Lazy<Tera> = Lazy::new(|| {
  .unwrap();
  tera.register_filter("base64_encode", filters::base64_encode);
  tera.register_filter("base64_decode", filters::base64_decode);
+ tera.register_filter("regex_replace", filters::RegexReplaceFilter::new());
  tera
 });
 

components/utils/src/templates.rs

@@ -100,6 +100,16 @@ pub fn render_template(
  }
 }
 
+pub fn is_default_template(name: &str, tera: &Tera, theme: &Option<String>) -> Result<bool> {
+ if check_template_fallbacks(name, tera, theme).is_some() {
+ return Ok(false);
+ }
+ match name {
+ "index.html" | "section.html" | "page.html" | "single.html" | "list.html" => Ok(true),
+ _ => bail!("Template not found for {}", name),
+ }
+}
+
 /// Rewrites the path of duplicate templates to include the complete theme path
 /// Theme templates will be injected into site templates, with higher priority for site
 /// templates. To keep a copy of the template in case it's being extended from a site template

docs/content/documentation/templates/overview.md

@@ -86,6 +86,14 @@ Encode the variable to base64.
 ### base64_decode
 Decode the variable from base64.
 
+### regex_replace
+Replace text via regular expressions.
+
+```jinja2
+{{ "World Hello" | regex_replace(pattern=`(?P<subject>\w+), (?P<greeting>\w+)`, rep=`$greeting $subject`) }}
+<!-- Hello World -->
+```
+
 ### num_format
 Format a number into its string representation.
 

src/cmd/build.rs

@@ -33,5 +33,6 @@ pub fn build(
  site.load()?;
  messages::notify_site_size(&site);
  messages::warn_about_ignored_pages(&site);
+ messages::warn_about_default_templates(&site)?;
  site.build()
 }

src/cmd/check.rs

@@ -25,5 +25,6 @@ pub fn check(
  site.load()?;
  messages::check_site_summary(&site);
  messages::warn_about_ignored_pages(&site);
+ messages::warn_about_default_templates(&site)?;
  Ok(())
 }

src/cmd/serve.rs

@@ -281,6 +281,7 @@ fn create_new_site(
  }
  messages::notify_site_size(&site);
  messages::warn_about_ignored_pages(&site);
+ messages::warn_about_default_templates(&site)?;
  site.build()?;
  Ok((site, address))
 }

src/main.rs

@@ -2,6 +2,7 @@ use std::path::{Path, PathBuf};
 use std::time::Instant;
 
 use cli::{Cli, Command};
+use errors::anyhow;
 use utils::net::{get_available_port, port_is_available};
 
 use clap::{CommandFactory, Parser};
@@ -13,10 +14,17 @@ mod messages;
 mod prompt;
 
 fn get_config_file_path(dir: &Path, config_path: &Path) -> (PathBuf, PathBuf) {
- let root_dir = dir
- .ancestors()
- .find(|a| a.join(config_path).exists())
- .unwrap_or_else(|| panic!("could not find directory containing config file"));
+ let root_dir = dir.ancestors().find(|a| a.join(config_path).exists()).unwrap_or_else(|| {
+ messages::unravel_errors(
+ "",
+ &anyhow!(
+ "{} not found in current directory or ancestors, current_dir is {}",
+ config_path.display(),
+ dir.display()
+ ),
+ );
+ std::process::exit(1);
+ });
 
  // if we got here we found root_dir so config file should exist so we can unwrap safely
  let config_file = root_dir

src/messages.rs

@@ -2,7 +2,7 @@ use libs::time::Duration;
 use std::convert::TryInto;
 use std::time::Instant;
 
-use errors::Error;
+use errors::{Error, Result};
 use site::Site;
 
 /// Display in the console the number of pages/sections in the site
@@ -52,6 +52,15 @@ pub fn warn_about_ignored_pages(site: &Site) {
  }
 }
 
+/// Display a warning in the console if there are default templates rendered
+pub fn warn_about_default_templates(site: &Site) -> Result<()> {
+ let default_templates = site.get_default_templates()?;
+ for path_string in default_templates.iter() {
+ console::warn(&format!("- {} is using the default template", path_string));
+ }
+ Ok(())
+}
+
 /// Print the time elapsed rounded to 1 decimal
 pub fn report_elapsed_time(instant: Instant) {
  let duration: Duration = instant.elapsed().try_into().unwrap();