tikz-gallery-generator

 use serde::{
     de::{Deserializer, Error, Unexpected},
     Deserialize,
 };
 use std::{fmt::{self, Display}, path::PathBuf, fs::{self, Metadata}};
 
 const LICENSES: &[&str] = &[
     "proprietary",
     "PD",
     "CC0",
     "CC-BY-1",
     "CC-BY-2",
     "CC-BY-2.1",
     "CC-BY-2.5",
     "CC-BY-3",
     "CC-BY-4",
     "CC-BY-SA-1",
     "CC-BY-SA-2",
     "CC-BY-SA-2.1",
     "CC-BY-SA-2.5",
     "CC-BY-SA-3",
     "CC-BY-SA-4",
     "CC-BY-NC-1",
     "CC-BY-NC-2",
     "CC-BY-NC-2.1",
     "CC-BY-NC-2.5",
     "CC-BY-NC-3",
     "CC-BY-NC-4",
     "CC-BY-NC-SA-1",
     "CC-BY-NC-SA-2",
     "CC-BY-NC-SA-2.1",
     "CC-BY-NC-SA-2.5",
     "CC-BY-NC-SA-3",
     "CC-BY-NC-SA-4",
     "CC-BY-ND-1",
     "CC-BY-ND-2",
     "CC-BY-ND-2.1",
     "CC-BY-ND-2.5",
     "CC-BY-ND-3",
     "CC-BY-ND-4",
     "CC-BY-NC-ND-1",
     "CC-BY-NC-ND-2",
     "CC-BY-NC-ND-2.1",
     "CC-BY-NC-ND-2.5",
     "CC-BY-NC-ND-3",
     "CC-BY-NC-ND-4",
 ];
 
 const FILE_FORMATS: &[&str] = &["tikz", "eps", "png", "jpeg", "jpg"];
 
 /// Info on a individual entry on the gallery
 #[derive(Debug, Clone)]
 pub struct GalleryEntry {
     pub path: PathBuf,
     pub file_name: String,
     pub file_format: FileFormat,
     pub alt: String,
     pub caption: Option<String>,
     pub license: LicenseType,
     pub source: Option<String>,
     pub author: String,
     pub author_url: Option<String>,
     pub metadata: Option<Metadata>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum FileFormat {
     TeX,
     Svg,
     Png,
     Jpeg,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum LicenseType {
     PublicDomain,
     Cc(CreativeCommons),
     Proprietary,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct CreativeCommons(CcInternal);
 
 #[derive(Debug, Clone, Copy)]
 /// Wrapper for printing the url of a Creative Commons license
 pub struct LicenseUrl(CcInternal);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum CcInternal {
     /// Creative Commons (without attribution)
     Cc0,
     /// Creative Commons Attributions (derivatives allowed)
     CcBy {
         version: CcVersion,
         non_commercial: bool,
         share_alike: bool,
     },
     // The ND (non-derivatives) option excludes the SA (share alike) option
     /// Creative Commons Attributions Non-Derivatives
     CcByNd {
         version: CcVersion,
         non_commercial: bool,
     },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum CcVersion {
     One,
     Two,
     TwoOne,
     TwoFive,
     Three,
     Four,
 }
 
 impl CreativeCommons {
     pub const fn url(&self) -> LicenseUrl {
         LicenseUrl(self.0)
     }
 }
 
 impl LicenseType {
     pub fn parse(s: &str) -> Result<Self, ()> {
         if !LICENSES.contains(&s) {
             return Err(());
         }
 
         if s == "proprietary" {
             return Ok(Self::Proprietary);
         } else if s == "PD" {
             return Ok(Self::PublicDomain);
         } else if s == "CC0" {
             return Ok(Self::Cc(CreativeCommons(CcInternal::Cc0)));
         }
 
         assert!(s.len() >= 3,
                 "if s is in LICENSES it should contain at least 3 chars");
 
         let (license, version) = s.rsplit_once('-').ok_or(())?;
 
         let version = match version {
             "1"   => CcVersion::One,
             "2"   => CcVersion::Two,
             "2.1" => CcVersion::TwoOne,
             "2.5" => CcVersion::TwoFive,
             "3"   => CcVersion::Three,
             "4"   => CcVersion::Four,
             _     => {
                 unreachable!("if s is in LICENSES we should be able to parse the license version")
             },
         };
 
         match license {
             "CC-BY" => {
                 Ok(Self::Cc(CreativeCommons(CcInternal::CcBy {
                     version,
                     non_commercial: false,
                     share_alike: false,
                 })))
             },
             "CC-BY-NC" => {
                 Ok(Self::Cc(CreativeCommons(CcInternal::CcBy {
                     version,
                     non_commercial: true,
                     share_alike: false,
                 })))
             },
             "CC-BY-SA" => {
                 Ok(Self::Cc(CreativeCommons(CcInternal::CcBy {
                     version,
                     non_commercial: false,
                     share_alike: true,
                 })))
             },
             "CC-BY-NC-SA" => {
                 Ok(Self::Cc(CreativeCommons(CcInternal::CcBy {
                     version,
                     non_commercial: true,
                     share_alike: true,
                 })))
             },
             "CC-BY-ND" => {
                 Ok(Self::Cc(CreativeCommons(CcInternal::CcByNd {
                     version,
                     non_commercial: false,
                 })))
             },
             "CC-BY-NC-ND" => {
                 Ok(Self::Cc(CreativeCommons(CcInternal::CcByNd {
                     version,
                     non_commercial: true,
                 })))
             },
             _ => {
                 unreachable!("if s is in LICENSES we should be able to parse the license-type")
             },
         }
     }
 }
 
 impl<'de> Deserialize<'de> for GalleryEntry {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
         #[derive(Deserialize)]
         struct Info {
             path: String,
             alt: String,
             caption: Option<String>,
             license: String,
             author: String,
             source: Option<String>,
             #[serde(alias = "author-url")]
             author_url: Option<String>,
         }
 
         let Info {
             path: path_str,
             alt,
             caption,
             license,
             author,
             author_url,
             source,
         } = Info::deserialize(deserializer)?;
 
         let license = LicenseType::parse(&license)
             .map_err(|_| D::Error::unknown_variant(&license, LICENSES))?;
         let path = PathBuf::from(&path_str);
 
         let file_format = match path.extension().and_then(|s| s.to_str()) {
             None => {
                 return Err(D::Error::invalid_value(
                     Unexpected::Str(&path_str),
                     &"valid file path (couldn't guess file format)",
                 ));
             }
             Some("tex")          => FileFormat::TeX,
             Some("svg")          => FileFormat::Svg,
             Some("png")          => FileFormat::Png,
             Some("jpeg" | "jpg") => FileFormat::Jpeg,
             Some(ext) => {
                 return Err(D::Error::unknown_variant(ext, FILE_FORMATS));
             }
         };
 
         if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
             Ok(Self {
                 path: path.clone(),
                 alt: alt.trim().to_string(),
                 file_name: String::from(file_name),
                 source,
                 file_format,
                 caption,
                 author: author.trim().to_string(),
                 author_url: author_url.map(|s| s.trim().to_string()),
                 metadata: fs::symlink_metadata(&path).ok(),
                 license,
             })
         } else {
             Err(D::Error::invalid_value(
                 Unexpected::Str(&path_str),
                 &"valid file path (couldn't extract file name)",
             ))
         }
     }
 }
 
 impl Display for CreativeCommons {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match self.0 {
             CcInternal::Cc0 => write!(f, "CC0"),
             CcInternal::CcBy { version, non_commercial, share_alike } => {
                 write!(f, "CC-BY")?;
                 if non_commercial {
                     write!(f, "-NC")?;
                 }
                 if share_alike {
                     write!(f, "-SA")?;
                 }
                 write!(f, " {version}")
             },
             CcInternal::CcByNd { version, non_commercial } => {
                 write!(f, "CC-BY")?;
                 if non_commercial {
                     write!(f, "-NC")?;
                 }
                 write!(f, "-ND {version}")
             }
         }
     }
 }
 
 impl Display for CcVersion {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
             CcVersion::One     => write!(f, "1.0"),
             CcVersion::Two     => write!(f, "2.0"),
             CcVersion::TwoOne  => write!(f, "2.1"),
             CcVersion::TwoFive => write!(f, "2.5"),
             CcVersion::Three   => write!(f, "3.0"),
             CcVersion::Four    => write!(f, "4.0"),
         }
     }
 }
 
 impl Display for LicenseUrl {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match self.0 {
             // CC0
             CcInternal::Cc0 => {
                 write!(f, "https://creativecommons.org/publicdomain/zero/1.0/")
             },
             // CC-BY-x
             CcInternal::CcBy {
                 version,
                 non_commercial: false,
                 share_alike: false,
             } => {
                 write!(f, "http://creativecommons.org/licenses/by/{version}/")
             }
             // CC-BY-SA-x
             CcInternal::CcBy {
                 version,
                 non_commercial: false,
                 share_alike: true,
             } => {
                 write!(
                     f,
                     "http://creativecommons.org/licenses/by-sa/{version}/"
                 )
             }
             // CC-BY-NC-x
             CcInternal::CcBy {
                 version,
                 non_commercial: true,
                 share_alike: false,
             } => {
                 write!(
                     f,
                     "http://creativecommons.org/licenses/by-nc/{version}/"
                 )
             }
             // CC-BY-NC-SA-x
             CcInternal::CcBy {
                 version,
                 non_commercial: true,
                 share_alike: true,
             } => {
                 write!(
                     f,
                     "http://creativecommons.org/licenses/by-nc-sa/{version}/"
                 )
             }
             // CC-BY-ND-x
             CcInternal::CcByNd { version, non_commercial: false, } => {
                 write!(
                     f,
                     "http://creativecommons.org/licenses/by-nd/{version}/"
                 )
             }
             // CC-BY-NC-ND-x
             CcInternal::CcByNd { version, non_commercial: true, } => {
                 write!(
                     f,
                     "http://creativecommons.org/licenses/by-nc-nd/{version}/"
                 )
             }
         }
     }
 }