stapix

 use crossterm::style::Stylize;
 use image::{DynamicImage, io::Reader as ImageReader};
 use std::{
     cmp::min,
     env,
     fmt::{self, Display},
     fs::{self, File},
     io::{self, Write},
     path::{PathBuf, Path},
     process::ExitCode,
     sync::mpsc,
 };
 use gallery_entry::{GalleryEntry, LicenseType};
 use threadpool::ThreadPool;
 
 #[macro_use]
 mod log;
 mod gallery_entry;
 
 /// A wrapper for HTML-escaped strings
 struct Escaped<'a>(pub &'a str);
 
 /// A wrapper to display lists of command line arguments
 struct ArgList<'a>(pub &'a [String]);
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum RenderResult {
     Skipped,
     Success,
     Failure,
 }
 
 const FULL_BUILD_OPT: &str = "--full-build";
 
 const TARGET_PATH:  &str = "./site";
 const PAGES_PATH:   &str = "pix";
 const PHOTOS_PATH:  &str = "assets/photos";
 const THUMBS_PATH:  &str = "assets/thumbs";
 const FAVICON_PATH: &str = "assets/favicon.ico";
 const ICON_PATH:    &str = "assets/icon.svg";
 const STYLES_PATH:  &str = "styles.css";
 
 const PAGE_TITLE: &str = "Pablo&apos;s Photo Gallery";
 const AUTHOR: &str = "Pablo";
 const LICENSE: &str = "GPLv3";
 
 /// WebP image quality
 const IMAGE_QUALITY: f32 = 50.0;
 
 /// Target height of the thumbnails, depending on wether the image is vertical
 /// or horizontal
 const HORIZONTAL_THUMB_HEIGHT: u32 = 300;
 const VERTICAL_THUMB_HEIGHT:   u32 = 800;
 
 fn main() -> ExitCode {
     infoln!("Running {package} version {version}",
            package = env!("CARGO_PKG_NAME"),
            version = env!("CARGO_PKG_VERSION"));
 
     let args: Vec<String> = env::args().collect();
 
     let (program, config, full_build) = match &args[..] {
         [program, config] => (program, config, false),
         [program, config, opt] if opt == FULL_BUILD_OPT => {
             (program, config, true)
         }
         [program, _config, ..] => {
             errorln!("Unknown arguments: {}", ArgList(&args[2..]));
             usage!(program);
             return ExitCode::FAILURE;
         }
         [program] => {
             errorln!("Expected 1 command line argument, found none");
             usage!(program);
             return ExitCode::FAILURE;
         }
         [] => unreachable!("args always contains at least the input program"),
     };
 
     let f = File::open(config);
     match f.map(serde_yaml::from_reader::<_, Vec<GalleryEntry>>) {
         // Error opening the config file
         Err(err) => {
             errorln!("Couldn't open {config:?}: {err}");
             usage!(program);
             ExitCode::FAILURE
         }
         // Error parsing the config file
         Ok(Err(err)) => {
             errorln!("Couldn't parse {config:?}: {err}");
             usage_config!();
             ExitCode::FAILURE
         }
         Ok(Ok(pics)) => render_gallery(pics, full_build),
     }
 }
 
 /// Coordinates the rendering of all the pages and file conversions
 fn render_gallery(pics: Vec<GalleryEntry>, full_build: bool) -> ExitCode {
     info!("Copying image files to the target directory...");
 
     for pic in &pics {
         let mut target_path = PathBuf::from(TARGET_PATH);
         target_path.push(PHOTOS_PATH);
         target_path.push(&pic.file_name);
 
         if let Err(err) = fs::copy(&pic.path, &target_path) {
             errorln!(
                 "Couldn't copy file {src:?} to {target:?}: {err}",
                src = pic.path,
                target = target_path,
            );
             return ExitCode::FAILURE;
         }
     }
 
     info_done!();
 
     // ========================================================================
     for pic in &pics {
         if pic.alt.is_empty() {
             warnln!(
                 "Empty text alternative was specified for the file {name:?}",
                 name = pic.file_name
             );
         }
     }
 
     // ========================================================================
     let num_threads = min(num_cpus::get() + 1, pics.len());
     let rendering_pool = ThreadPool::with_name(
         String::from("thumbnails renderer"),
         num_threads
     );
     let (sender, reciever) = mpsc::channel();
 
     infoln!("Started rendering WebP thumbnails (using {n} threads)",
          n = num_threads);
 
     for pic in &pics {
         let sender = sender.clone();
         let pic = pic.clone();
         rendering_pool.execute(move || {
             sender.send(render_thumbnail(pic, full_build))
                 .expect("channel should still be alive awaiting for the completion of this task");
         });
     }
 
     for _ in 0..pics.len() {
         match reciever.recv() {
             Ok(RenderResult::Failure) => return ExitCode::FAILURE,
             Ok(RenderResult::Success | RenderResult::Skipped)  => {}
             Err(_)    => {
                 // Propagate the panic to the main thread: reciever.recv should
                 // only fail if some of the rendering threads panicked
                 panic!("rendering thread panicked!");
             }
         }
     }
 
     infoln!("Done rendering WebP thumbnails!");
 
     // ========================================================================
     info!("Rendering index.html...");
     if render_index(&pics).is_err() {
         return ExitCode::FAILURE;
     }
     info_done!();
 
     for pic in pics {
         info!("Rendering HTML page for {name:?}...", name = pic.file_name);
         match render_pic_page(&pic, full_build) {
             RenderResult::Success => info_done!(),
             RenderResult::Skipped => {
                 info_done!("Skipped! (use {FULL_BUILD_OPT} to overwrite)");
             }
             RenderResult::Failure => return ExitCode::FAILURE,
         }
     }
 
     ExitCode::SUCCESS
 }
 
 fn render_index(pics: &Vec<GalleryEntry>) -> io::Result<()> {
     let mut path = PathBuf::from(TARGET_PATH);
     path.push("index.html");
 
     let mut f = File::create(path)?;
 
     writeln!(f, "<!DOCTYPE html>")?;
     write_license(&mut f)?;
     writeln!(f, "<html lang=\"en\">")?;
     writeln!(f, "<head>")?;
     writeln!(f, "<title>{PAGE_TITLE}</title>")?;
     write_head(&mut f)?;
 
     for pic in pics.iter().take(10) {
         // TODO: Preload mp4 thumbnails for GIF files
         writeln!(
             f,
             "<link rel=\"preload\" as=\"image\" href=\"/{THUMBS_PATH}/{name}.webp\">",
             name = Escaped(&pic.file_name)
         )?;
     }
 
     writeln!(f, "</head>")?;
 
     writeln!(f, "<body>")?;
     write_nav(&mut f)?;
     writeln!(f, "<main>")?;
     writeln!(f, "<ul id=\"gallery\">")?;
 
     for pic in pics {
         writeln!(f, "<li>")?;
         writeln!(
             f,
             "<a aria-label=\"{name}\" href=\"/{PAGES_PATH}/{name}.html\">",
             name = Escaped(&pic.file_name)
         )?;
         // TODO: Link to mp4 thumbnails for GIF files
         writeln!(
             f,
             "<img alt=\"{alt}\" src=\"/{THUMBS_PATH}/{name}.webp\">",
             alt = Escaped(&pic.alt),
             name = Escaped(&pic.file_name)
         )?;
         writeln!(f, "</a>\n</li>")?;
     }
 
     writeln!(f, "</ul>")?;
     writeln!(f, "</main>")?;
 
     writeln!(f, "<footer>")?;
     writeln!(
         f,
         "made with 💛 by <a role=\"author\" href=\"https://pablopie.xyz\">@pablo</a>"
     )?;
     writeln!(f, "</footer>")?;
 
     writeln!(f, "</body>")?;
     writeln!(f, "</html>")
 }
 
 fn render_pic_page(pic: &GalleryEntry, full_build: bool) -> RenderResult {
     let mut path = PathBuf::from(TARGET_PATH);
     path.push(PAGES_PATH);
     path.push(pic.file_name.clone() + ".html");
 
     // Only try to re-render HTML page in case the page is older than the
     // image file
     if !full_build && !needs_update(&path, &pic.path) {
         return RenderResult::Skipped;
     }
 
     let mut f = match File::create(&path) {
         Ok(file) => file,
         Err(err) => {
             errorln!("Could not open file {path:?}: {err}");
             return RenderResult::Failure;
         }
     };
 
     /// Does the deeds
     fn write_file(f: &mut File, pic: &GalleryEntry) -> io::Result<()> {
         writeln!(f, "<!DOCTYPE html>")?;
         write_license(f)?;
         writeln!(f, "<html lang=\"en\">")?;
         writeln!(f, "<head>")?;
         writeln!(
             f,
             "<title>{PAGE_TITLE} &dash; {name}</title>",
             name = Escaped(&pic.file_name)
         )?;
         write_head(f)?;
         writeln!(
             f,
             "<link rel=\"preload\" as=\"image\" href=\"/{PHOTOS_PATH}/{n}\">",
             n = Escaped(&pic.file_name)
         )?;
         writeln!(f, "</head>")?;
 
         writeln!(f, "<body>")?;
         write_nav(f)?;
 
         writeln!(f, "<main>")?;
         if pic.caption.is_some() {
             writeln!(f, "<figure>")?;
         } else {
             writeln!(f, "<figure aria-label=\"File {name}\">",
                      name = Escaped(&pic.file_name))?;
         }
         writeln!(f, "<div id=\"picture-container\">")?;
         writeln!(
             f,
             "<img alt=\"{alt}\" src=\"/{PHOTOS_PATH}/{file_name}\">",
             alt = Escaped(&pic.alt),
             file_name = Escaped(&pic.file_name)
         )?;
         writeln!(f, "</div>")?;
         if let Some(caption) = &pic.caption {
             writeln!(f, "<figcaption>")?;
             writeln!(f, "{}", Escaped(caption))?;
             writeln!(f, "</figcaption>")?;
         }
         writeln!(f, "</figure>")?;
         writeln!(f, "</main>")?;
 
         writeln!(f, "<footer>")?;
         write!(f, "original work by ")?;
         if let Some(url) = &pic.author_url {
             writeln!(f, "<a role=\"author\" href=\"{url}\">{author}</a>",
                      author = Escaped(&pic.author))?;
         } else {
             writeln!(f, "{}", Escaped(&pic.author))?;
         }
         writeln!(f, "<br>")?;
         if let LicenseType::Cc(license) = &pic.license {
             writeln!(f, "licensed under <a role=\"license\" href=\"{url}\">{license}</a>",
                      url = license.url())?;
         } else {
             writeln!(f, "this is public domain")?;
         }
         writeln!(f, "</footer>")?;
 
         writeln!(f, "</body>")?;
         writeln!(f, "</html>")
     }
 
     if let Err(err) = write_file(&mut f, pic) {
         errorln!("Could not write to {path:?}: {err}");
         RenderResult::Failure
     } else {
         RenderResult::Success
     }
 }
 
 fn write_nav(f: &mut File) -> io::Result<()> {
     writeln!(f, "<header>")?;
     writeln!(f, "<nav>")?;
     writeln!(f, "<img aria-hidden=\"true\" alt=\"Website icon\" width=\"24\" height=\"24\" src=\"/{ICON_PATH}\">")?;
     writeln!(f, "<a href=\"/index.html\">photos.pablopie.xyz</a>")?;
     writeln!(f, "</nav>")?;
     writeln!(f, "</header>")
 }
 
 /// Prints the common head elements to a given file
 fn write_head(f: &mut File) -> io::Result<()> {
     writeln!(
         f,
         "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">"
     )?;
     writeln!(f, "<meta name=\"author\" content=\"{AUTHOR}\">")?;
     writeln!(f, "<meta name=\"copyright\" content=\"{LICENSE}\">")?;
     writeln!(
         f,
         "<meta content=\"text/html; charset=utf-8\" http-equiv=\"content-type\">"
     )?;
     writeln!(f, "<link rel=\"icon\" href=\"/{FAVICON_PATH}\" type=\"image/x-icon\" sizes=\"16x16 24x24 32x32\">")?;
     writeln!(f, "<link rel=\"stylesheet\" href=\"/{STYLES_PATH}\">")
 }
 
 /// Prints a HTML comment with GPL licensing info
 fn write_license(f: &mut File) -> io::Result<()> {
     writeln!(
         f,
         "<!-- This program is free software: you can redistribute it and/or modify"
     )?;
     writeln!(
         f,
         "     it under the terms of the GNU General Public License as published by"
     )?;
     writeln!(
         f,
         "     the Free Software Foundation, either version 3 of the License, or"
     )?;
     writeln!(f, "     (at your option) any later version.\n")?;
     writeln!(
         f,
         "     This program is distributed in the hope that it will be useful,"
     )?;
     writeln!(
         f,
         "     but WITHOUT ANY WARRANTY; without even the implied warranty of"
     )?;
     writeln!(
         f,
         "     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the"
     )?;
     writeln!(f, "     GNU General Public License for more details.\n")?;
     writeln!(
         f,
         "     You should have received a copy of the GNU General Public License"
     )?;
     writeln!(
         f,
         "     along with this program. If not, see <https://www.gnu.org/licenses/>. -->"
     )
 }
 
 // TODO: Render GIF files as mp4 instead
 fn render_thumbnail(pic: GalleryEntry, full_build: bool) -> RenderResult {
     let mut thumb_path = PathBuf::from(TARGET_PATH);
     thumb_path.push(THUMBS_PATH);
     thumb_path.push(pic.file_name.clone() + ".webp");
 
     // Only try to render thumbnail in case the thumbnail file in the machine
     // is older than the source file
     if !full_build && !needs_update(&thumb_path, &pic.path) {
         warnln!(
             "Skipped rendering the thumbnail for {name:?} (use {FULL_BUILD_OPT} to overwrite)",
             name = pic.file_name
         );
         return RenderResult::Skipped;
     }
 
     let mut thumb_file = match File::create(&thumb_path) {
         Ok(f)    => f,
         Err(err) => {
             errorln!(
                 "Couldn't open WebP thumbnail file {thumb_path:?}: {err}"
             );
             return RenderResult::Failure;
         }
     };
 
     let img_reader = match ImageReader::open(&pic.path) {
         Ok(r)    => r,
         Err(err) => {
             errorln!(
                 "Couldn't open file {path:?} to render WebP thumbnail: {err}",
                 path = pic.file_name,
                 err = err
             );
             return RenderResult::Failure;
         }
     };
 
     let img = match img_reader.decode() {
         Ok(img)  => img,
         Err(err) => {
             errorln!(
                 "Faileded to decode image file {name:?}: {err}",
                 name = pic.file_name,
             );
             return RenderResult::Failure;
         }
     };
 
     let h = if img.width() > img.height() {
         HORIZONTAL_THUMB_HEIGHT
     } else {
         VERTICAL_THUMB_HEIGHT
     };
     let w = (h * img.width()) / img.height();
 
     // We should make sure that the image is in the RGBA8 format so that
     // the webp crate can encode it
     let img = DynamicImage::from(img.thumbnail(w, h).into_rgba8());
     let mem = webp::Encoder::from_image(&img)
         .expect("image should be in the RGBA8 format")
         .encode(IMAGE_QUALITY);
 
     if let Err(err) = thumb_file.write_all(&mem) {
         errorln!(
             "Couldn't write WebP thumnail to file {path:?}: {err}",
             path = thumb_path
         );
         return RenderResult::Failure;
     }
 
     infoln!("Rendered WebP thumbnail for {name:?}", name = pic.file_name);
     RenderResult::Success
 }
 
 /// Returns `false` if both `p1` and `p2` exist and and `p1` is newer than
 /// `f2`. Returns `true` otherwise
 fn needs_update<P1: AsRef<Path>, P2: AsRef<Path>>(p1: P1, p2: P2) -> bool {
     if let (Ok(m1), Ok(m2)) = (fs::metadata(&p1), fs::metadata(&p2)) {
         if m1.modified().unwrap() > m2.modified().unwrap() {
             return false;
         }
     }
 
     true
 }
 
 impl<'a> Display for Escaped<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         for c in self.0.chars() {
             match c {
                 '<'  => write!(f, "&lt;")?,
                 '>'  => write!(f, "&gt;")?,
                 '&'  => write!(f, "&amp;")?,
                 '"'  => write!(f, "&quot;")?,
                 '\'' => write!(f, "&apos;")?,
                 c    => c.fmt(f)?,
             }
         }
 
         Ok(())
     }
 }
 
 impl<'a> Display for ArgList<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         let mut first = true;
 
         for arg in self.0 {
             if first {
                 first = false;
                 write!(f, "{:?}", arg)?;
             } else {
                 write!(f, " {:?}", arg)?;
             }
         }
 
         Ok(())
     }
 }