Reduce dependencies

Author: grego

Cargo.lock

@@ -16,33 +16,34 @@ ramhorns = { git = "https://github.com/grego/ramhorns", branch = "shorthand" }
 arrayvec = { version = "0.7", features = ["serde"] }
 beef = { version = "0.5", features = ["impl_serde"]}
 serde = { version = "^1.0.126", features = ["derive"] }
-chrono = { version = "^0.4.19", features = ["clock", "serde"], default_features = false }
+chrono = { version = "^0.4.19", features = ["std", "serde"], default_features = false }
 fnv = "1.0"
-ahash = "0.7"
-hashbrown = { version = "0.11.2", features = ["inline-more", "serde"], default_features = false }
-parking_lot = "0.11.1"
+hashbrown = { version = "0.12.1", features = ["inline-more", "serde"], default_features = false }
 serde-cmd = "0.1.3"
-pulldown-cmark = "0.9"
+pulldown-cmark = { version = "0.9", default_features = false }
 cmark-syntax = "0.3"
 
 # Cargo doesn't support binary-only dependencies yet.
-toml = { version = "0.5.8", optional = true }
-rayon = { version = "1.5.1", optional = true }
-structopt = { version = "0.3.22", optional = true }
-thiserror = { version = "1.0.26", optional = true }
+toml = { version = "0.5.9", optional = true }
+rayon = { version = "1.5.3", optional = true }
+clap = { version = "3.1.18", optional = true, default_features = false, features = ["std"] }
+clap_derive = { version = "3.1.18", optional = true }
+thiserror = { version = "1.0.31", optional = true }
 serde_json = { version = "1", optional = true }
 
 [features]
-bin = ["toml", "rayon", "structopt", "thiserror", "serde_json", "hashbrown/rayon"]
+bin = ["toml", "rayon", "clap", "clap_derive", "thiserror", "serde_json", "hashbrown/rayon"]
 mathml = ["cmark-syntax/latex2mathml"]
 default = ["bin", "mathml"]
 
 [profile.release]
 lto = true
+opt-level = 3
+strip = "debuginfo"
+codegen-units = 1
 
 [profile.bench]
 lto = true
 
 [patch.crates-io]
 ramhorns-derive = { git = "https://github.com/grego/ramhorns", branch = "shorthand" }
-

Cargo.toml

@@ -7,10 +7,10 @@ const RENDERED_BYTES: u64 =
     "Hello, Ramhorns!This is a really simple test of the rendering!<title></title><h1></h1><div></div>".len() as u64;
 
 #[bench]
-fn ahash_hashmap(b: &mut Bencher) {
+fn fnv_hashmap(b: &mut Bencher) {
     let tpl = ramhorns::Template::new(SOURCE).unwrap();
 
-    let mut map: std::collections::HashMap<_, _, ahash::RandomState> = Default::default();
+    let mut map: std::collections::HashMap<_, _, fnv::FnvBuildHasher> = Default::default();
     map.insert("title", "Hello, Ramhorns!");
     map.insert("body", "This is a really simple test of the rendering!");
 

benches/main.rs

@@ -6,7 +6,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     std::io::stdin().read_to_end(&mut source)?;
     // When deserializing from a slice, zero-copy deserialiation can be used
     let mut pages: Vec<Page> = serde_json::from_slice(&source)?;
-    
+
     for page in &mut pages {
         if page.content.find("dog").is_some() {
             page.summary = "WARNING! CONTAINS DOGS!".into();

examples/transform_plugin.rs

@@ -8,7 +8,7 @@
 // along with Blades.  If not, see <http://www.gnu.org/licenses/>
 use blades::*;
 
-use chrono::offset::Local;
+use clap::Parser as ClapParser;
 use ramhorns::{Content, Template};
 use rayon::prelude::*;
 use std::env::var;
@@ -17,23 +17,22 @@ use std::fs::{create_dir_all, read_to_string, write};
 use std::io::{stdin, stdout, BufRead, BufReader, Lines, Write};
 use std::path::Path;
 use std::process::{Command, Output, Stdio};
-use std::time::Instant;
-use structopt::StructOpt;
+use std::time::{Instant, SystemTime};
 use thiserror::Error;
 
 static CONFIG_FILE: &str = "Blades.toml";
 
-#[derive(StructOpt)]
+#[derive(clap_derive::Parser)]
 /// Blazing fast Dead simple Static site generator
 struct Opt {
     /// File to read the site config from
-    #[structopt(short, long, default_value = CONFIG_FILE)]
+    #[clap(short, long, default_value = CONFIG_FILE)]
     config: String,
-    #[structopt(subcommand)]
+    #[clap(subcommand)]
     cmd: Option<Cmd>,
 }
 
-#[derive(PartialEq, StructOpt)]
+#[derive(PartialEq, clap_derive::Subcommand)]
 enum Cmd {
     /// Initialise the site in the current directory, creating the basic files and folders
     Init,
@@ -228,7 +227,9 @@ fn new_page(config: &Config) -> Result<(), Error> {
         "Path (relative to the content directory):",
     )?);
     create_dir_all(&path)?;
-    let date = Local::now().format("%Y-%m-%d").to_string();
+
+    let date: chrono::DateTime<chrono::Utc> = SystemTime::now().into();
+    let date = date.format("%Y-%m-%d").to_string();
     path.push(format!("{}-{}.toml", &date, &slug));
 
     if path.exists() {
@@ -374,7 +375,7 @@ fn build(config: &Config) -> Result<(), Error> {
                     taxonomy.render_key((n, l), config, &taxonomies, &pages, &templates, &rendered)
                 })
             })?;
-            render_meta(&pages, &taxonomies, config, &rendered).map_err(Into::into)
+            render_meta(&pages, &taxonomies, config).map_err(Into::into)
         },
     );
     res_l?;
@@ -401,7 +402,7 @@ fn build(config: &Config) -> Result<(), Error> {
 }
 
 fn main() {
-    let opt = Opt::from_args();
+    let opt: Opt = ClapParser::parse();
     let start = Instant::now();
 
     let config_file = match std::fs::read_to_string(&opt.config) {

src/main.rs

@@ -139,7 +139,7 @@ impl<P: Parser> Sources<P> {
             let read = File::open(&path)?.read_to_end(&mut self.data)?;
             let mid = start + read;
             let path = path.to_string_lossy();
-            let ext_start = path.rfind('.').unwrap_or_else(|| path.len());
+            let ext_start = path.rfind('.').unwrap_or(path.len());
             self.data.extend_from_slice(path[..ext_start].as_ref());
             let end = self.data.len();
             self.sources

src/sources.rs

@@ -45,7 +45,7 @@ where
 {
     let path = path.into();
     template.render_to_file(&path, content)?;
-    if let Some(path) = rendered.lock().replace(path) {
+    if let Some(path) = rendered.lock().unwrap().replace(path) {
         println!("Warning: more paths render to {}", path.to_string_lossy());
     }
     Ok(())
@@ -61,14 +61,10 @@ struct Meta<'p, 'r>(
 
 impl<'p> Meta<'p, '_> {
     #[inline]
-    fn render(
-        &self,
-        name: &str,
-        template: &str,
-        path: &Path,
-        rendered: &MutSet,
-    ) -> Result<(), ramhorns::Error> {
-        render(&Template::new(template)?, path.join(name), self, rendered)
+    fn render(&self, name: &str, template: &str, path: &Path) -> Result<(), ramhorns::Error> {
+        Template::new(template)?
+            .render_to_file(path.join(name), self)
+            .map_err(Into::into)
     }
 }
 
@@ -77,23 +73,22 @@ pub fn render_meta<'p>(
     pages: &[Page<'p>],
     taxons: &Classification<'p, '_>,
     config: &Config<'p>,
-    rendered: &MutSet,
 ) -> Result<(), ramhorns::Error> {
     let pages = PageList::new(pages, 0..pages.len(), 0, &config.url);
     let meta = Meta(DateTime::now(), pages, TaxonList(taxons), config);
     let path = Path::new(config.output_dir.as_ref());
 
     if config.sitemap {
         let sitemap = include_str!("templates/sitemap.xml");
-        meta.render("sitemap.xml", sitemap, path, rendered)?;
+        meta.render("sitemap.xml", sitemap, path)?;
     }
     if config.rss {
         let rss = include_str!("templates/rss.xml");
-        meta.render("rss.xml", rss, path, rendered)?;
+        meta.render("rss.xml", rss, path)?;
     }
     if config.atom {
         let atom = include_str!("templates/atom.xml");
-        meta.render("atom.xml", atom, path, rendered)?;
+        meta.render("atom.xml", atom, path)?;
     }
     Ok(())
 }
@@ -146,7 +141,7 @@ pub fn colocate_assets(config: &Config) -> Result<(), io::Error> {
 /// Delete all the pages that were present in the previous render, but not the current one.
 /// Then, write all the paths that were rendered to the file `filelist`
 pub fn cleanup(rendered: MutSet, filelist: &str) -> Result<(), io::Error> {
-    let rendered = rendered.into_inner();
+    let rendered = rendered.into_inner().unwrap();
     if let Ok(f) = File::open(filelist) {
         BufReader::new(f).lines().try_for_each(|filename| {
             let filename = filename?;

src/tasks.rs

@@ -19,10 +19,11 @@ use std::fmt;
 use std::hash::Hash;
 use std::ops::{Deref, DerefMut};
 use std::path::{is_separator, PathBuf};
+use std::sync::Mutex;
 use std::time::SystemTime;
 
 /// A set of all rendered paths. Behind a mutex, so it can be written from multiple threads.
-pub type MutSet<T = PathBuf> = parking_lot::Mutex<HashSet<T, ahash::RandomState>>;
+pub type MutSet<T = PathBuf> = Mutex<HashSet<T, fnv::FnvBuildHasher>>;
 
 /// A hash map wrapper that can render fields directly by the hash.
 #[derive(Clone, serde::Deserialize, serde::Serialize)]