avoid hard coding builtin names

1 files changed, 103 insertions, 47 deletions

diff --git a/src/vtcol.rs b/src/vtcol.rs
index 75bc699..5f9cc17 100644
--- a/src/vtcol.rs
+++ b/src/vtcol.rs
@@ -16,9 +16,9 @@ macro_rules! vrb {
 }
 
 const PALETTE_SIZE: usize = 16;
-const PALETTE_BYTES: usize = PALETTE_SIZE * 3; // 16 * sizeof(int)
+const PALETTE_BYTES: usize = PALETTE_SIZE * 3; /* 16 * sizeof(int) */
 
-const RAW_COLEXPR_SIZE: usize = 6; // e. g. 0xBADF00
+const RAW_COLEXPR_SIZE: usize = 6; /* e. g. 0xBADF00 */
 
 type RawPalette<'a> = [&'a str; PALETTE_SIZE];
 
@@ -103,17 +103,83 @@ impl fmt::Display for Color
     }
 } /* [impl fmt::Display for Color] */
 
+#[derive(Debug, Clone)]
+struct Builtin
+{
+    names:   &'static [&'static str],
+    palette: &'static RawPalette<'static>,
+}
+
+const BUILTIN_SCHEMES: &[Builtin] = &[
+    Builtin::solarized(),
+    Builtin::solarized_light(),
+    Builtin::default(),
+    Builtin::phosphor(),
+];
+
+impl Builtin
+{
+    fn name(&self) -> &'static str { self.names.iter().next().unwrap() }
+
+    const fn solarized() -> Self
+    {
+        Self {
+            names:   &["solarized", "solarized_dark", "sd"],
+            palette: &SOLARIZED_COLORS_DARK,
+        }
+    }
+
+    const fn solarized_light() -> Self
+    {
+        Self {
+            names:   &["solarized_light", "sl"],
+            palette: &SOLARIZED_COLORS_LIGHT,
+        }
+    }
+
+    const fn default() -> Self
+    {
+        Self {
+            names:   &["default", "normal", "linux"],
+            palette: &DEFAULT_COLORS,
+        }
+    }
+
+    const fn phosphor() -> Self
+    {
+        Self { names: &["phosphor", "matrix"], palette: &MONOCHROME_PHOSPHOR }
+    }
+}
+
+impl TryFrom<&str> for Builtin
+{
+    type Error = anyhow::Error;
+
+    fn try_from(name: &str) -> Result<Self, Self::Error>
+    {
+        for b in BUILTIN_SCHEMES {
+            if b.names.contains(&name) {
+                return Ok(b.clone());
+            }
+        }
+
+        Err(anyhow!("no such builtin: {}", name))
+    }
+}
+
+impl<'a> fmt::Display for Builtin
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
+    {
+        write!(f, "{}", self.name())
+    }
+}
+
 #[derive(Debug)]
 enum Scheme
 {
-    /** Vanilla Linux colors. */
-    Default,
-    /** The dark (default) version of the Solarized scheme. */
-    SolarizedDark,
-    /** The light version of the Solarized theme. */
-    SolarizedLight,
-    /** Bright green monochrome terminal. */
-    Phosphor,
+    /** One of the predefined schemes. */
+    Builtin(Builtin),
     /** Custom ``Palette``. */
     Palette(Palette),
     /** Load from file. */
@@ -125,10 +191,7 @@ impl<'a> fmt::Display for Scheme
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
     {
         match self {
-            Self::Default => write!(f, "default"),
-            Self::SolarizedDark => write!(f, "solarized_dark"),
-            Self::SolarizedLight => write!(f, "solarized_light"),
-            Self::Phosphor => write!(f, "phosphor"),
+            Self::Builtin(b) => write!(f, "{}", b),
             Self::Custom(None) => write!(f, "<read stdin>"),
             Self::Custom(Some(fname)) => write!(f, "{}", fname.display()),
             Self::Palette(pal) => write!(f, "palette: {}", pal),
@@ -152,13 +215,9 @@ impl From<&str> for Scheme
 {
     fn from(name: &str) -> Scheme
     {
-        match name {
-            "solarized" | "solarized_dark" | "sd" => Self::SolarizedDark,
-            "solarized_light" | "sl" => Self::SolarizedLight,
-            "phosphor" | "matrix" => Self::Phosphor,
-            "default" | "normal" => Self::Default,
-            path => Self::from_path(path),
-        }
+        Builtin::try_from(name)
+            .map(Self::Builtin)
+            .unwrap_or_else(|_| Self::from_path(name))
     }
 }
 
@@ -168,16 +227,16 @@ impl From<Palette> for Scheme
     fn from(pal: Palette) -> Scheme
     {
         if pal == Palette::from(&DEFAULT_COLORS) {
-            return Self::Default;
+            return Self::Builtin(Builtin::default());
         }
         if pal == Palette::from(&SOLARIZED_COLORS_DARK) {
-            return Self::SolarizedDark;
+            return Self::Builtin(Builtin::solarized());
         }
         if pal == Palette::from(&SOLARIZED_COLORS_LIGHT) {
-            return Self::SolarizedLight;
+            return Self::Builtin(Builtin::solarized_light());
         }
         if pal == Palette::from(&MONOCHROME_PHOSPHOR) {
-            return Self::Phosphor;
+            return Self::Builtin(Builtin::phosphor());
         }
 
         Self::Palette(pal)
@@ -327,24 +386,20 @@ impl<'a> Job
         }
     }
 
-    fn schemes()
+    fn list_schemes()
     {
-        println!("Available color schemes:");
-        println!("      * solarized_dark");
-        println!("      * solarized_light");
-        println!("      * phosphor");
-        println!("      * default");
+        println!("{} color schemes available:", BUILTIN_SCHEMES.len());
+        for s in BUILTIN_SCHEMES {
+            println!("      * {}", s.name());
+        }
     }
 
     fn dump(scm: Scheme)
     {
         vrb!("Dumping color scheme {}", scm);
         match scm {
-            Scheme::Default => Self::dump_scheme(&DEFAULT_COLORS),
-            Scheme::SolarizedDark => Self::dump_scheme(&SOLARIZED_COLORS_DARK),
-            Scheme::SolarizedLight =>
-                Self::dump_scheme(&SOLARIZED_COLORS_LIGHT),
-            Scheme::Phosphor => Self::dump_scheme(&MONOCHROME_PHOSPHOR),
+            Scheme::Builtin(Builtin { palette, .. }) =>
+                Self::dump_scheme(palette),
             Scheme::Custom(None) => Self::dump_palette(Palette::from_stdin()),
             Scheme::Custom(Some(fname)) =>
                 Self::dump_palette(Palette::from_file(&fname)),
@@ -364,7 +419,7 @@ impl<'a> Job
     {
         match self {
             Self::Dump(scm) => Self::dump(scm),
-            Self::List => Self::schemes(),
+            Self::List => Self::list_schemes(),
             Self::Set(scm) => Self::set_scheme(scm)?,
             Self::Get => Self::get_scheme()?,
             Self::Toggle(one, two) => Self::toggle_scheme(one, two)?,
@@ -434,7 +489,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 
-static CONSOLE_PATHS: [&str; 6] = [
+const CONSOLE_PATHS: [&str; 6] = [
     "/proc/self/fd/0",
     "/dev/tty",
     "/dev/tty0",
@@ -443,31 +498,35 @@ static CONSOLE_PATHS: [&str; 6] = [
     "/dev/console",
 ];
 
-static DEFAULT_COLORS: RawPalette = [
+/** Vanilla Linux colors. */
+const DEFAULT_COLORS: RawPalette = [
     "000000", "aa0000", "00aa00", "aa5500", "0000aa", "aa00aa", "00aaaa",
     "aaaaaa", "555555", "ff5555", "55ff55", "ffff55", "5555ff", "ff55ff",
     "55ffff", "ffffff",
 ];
 
-static SOLARIZED_COLORS_DARK: RawPalette = [
+/** The dark (default) version of the Solarized scheme. */
+const SOLARIZED_COLORS_DARK: RawPalette = [
     "002b36", "dc322f", "859900", "b58900", "268bd2", "d33682", "2aa198",
     "eee8d5", "002b36", "cb4b16", "586e75", "657b83", "839496", "6c71c4",
     "93a1a1", "fdf6e3",
 ];
 
-static SOLARIZED_COLORS_LIGHT: RawPalette = [
+/** The light version of the Solarized theme. */
+const SOLARIZED_COLORS_LIGHT: RawPalette = [
     "eee8d5", "dc322f", "859900", "b58900", "268bd2", "d33682", "2aa198",
     "073642", "fdf6e3", "cb4b16", "93a1a1", "839496", "657b83", "6c71c4",
     "586e75", "002b36",
 ];
 
-static MONOCHROME_PHOSPHOR: RawPalette = [
+/** Bright green monochrome terminal. */
+const MONOCHROME_PHOSPHOR: RawPalette = [
     "000000", "68fc68", "68fc68", "68fc68", "68fc68", "68fc68", "68fc68",
     "68fc68", "68fc68", "68fc68", "68fc68", "68fc68", "68fc68", "68fc68",
     "68fc68", "68fc68",
 ];
 
-static DUMMY_COLORS: RawPalette = [
+const DUMMY_COLORS: RawPalette = [
     "000000", "ffffff", "000000", "ffffff", "000000", "ffffff", "000000",
     "ffffff", "000000", "ffffff", "000000", "ffffff", "000000", "ffffff",
     "000000", "ffffff",
@@ -645,10 +704,7 @@ impl From<&Scheme> for Palette
     fn from(scm: &Scheme) -> Self
     {
         match scm {
-            Scheme::Default => Self::from(&DEFAULT_COLORS),
-            Scheme::SolarizedDark => Self::from(&SOLARIZED_COLORS_DARK),
-            Scheme::SolarizedLight => Self::from(&SOLARIZED_COLORS_LIGHT),
-            Scheme::Phosphor => Self::from(&MONOCHROME_PHOSPHOR),
+            Scheme::Builtin(Builtin { palette, .. }) => Self::from(*palette),
             Scheme::Custom(None) => Self::from_stdin(),
             Scheme::Custom(Some(ref fname)) => Self::from_file(fname),
             Scheme::Palette(pal) => pal.clone(),