feat: debug infos

NOTE: only debug mode is available

src/config.rs

@@ -4,27 +4,10 @@ use std::{fs, path::PathBuf};
 use crossterm::style::Color;
 use ini::configparser::ini::Ini;
 
-pub struct ComputableColor {
-    values: Vec<Color>,
-    current: usize,
-}
-
-impl ComputableColor {
-    fn from(color: Color) -> ComputableColor {
-        return ComputableColor {
-            values: vec![color],
-            current: 0,
-        };
-    }
-
-    pub fn update(&mut self) {
-        self.current = (self.current + 1) % self.values.len();
-    }
-
-    pub fn get_value(&self) -> Color {
-        return *self.values.get(self.current).unwrap();
-    }
-}
+use crate::{
+    color::{generate_gradient, parse_hex_color, ComputableColor},
+    debug,
+};
 
 pub struct Config {
     pub be_polite: bool,
@@ -102,33 +85,6 @@ fn load_term_color(value: i64) -> Color {
     }
 }
 
-fn parse_hex_color(value: &str) -> (u8, u8, u8) {
-    // Expand #XXX colors
-    let value = if value.len() == 3 {
-        format!(
-            "{}{}{}{}{}{}",
-            &value[0..1],
-            &value[0..1],
-            &value[1..2],
-            &value[1..2],
-            &value[2..3],
-            &value[2..3]
-        )
-    } else {
-        value.to_owned()
-    };
-
-    if value.len() != 6 {
-        panic!("ERROR: Invalid hex color: {}", value);
-    }
-
-    let r = u8::from_str_radix(&value[0..2], 16).unwrap();
-    let g = u8::from_str_radix(&value[2..4], 16).unwrap();
-    let b = u8::from_str_radix(&value[4..6], 16).unwrap();
-
-    return (r, g, b);
-}
-
 fn load_hex_color(value: &str) -> Color {
     let rgb = parse_hex_color(value);
     return Color::Rgb {
@@ -142,21 +98,6 @@ fn load_ansi_color(value: i64) -> Color {
     return Color::AnsiValue(value.try_into().unwrap());
 }
 
-fn clamp01(v: f32) -> f32 {
-    return if v < 0.0 {
-        0.0
-    } else if v > 1.0 {
-        1.0
-    } else {
-        v
-    };
-}
-
-fn lerp(a: u8, b: u8, t: f32) -> u8 {
-    let v = a as f32 + (b as f32 - a as f32) as f32 * clamp01(t);
-    return v as u8;
-}
-
 fn load_gradient(ini: &Ini) -> ComputableColor {
     let mut keys = Vec::new();
 
@@ -166,7 +107,7 @@ fn load_gradient(ini: &Ini) -> ComputableColor {
         i += 1;
     }
 
-    if ini.getbool("gradient", "gradient_loop").unwrap().unwrap() {
+    if !debug::is_debug() && ini.getbool("gradient", "gradient_loop").unwrap().unwrap() {
         let mut loop_keys = keys.clone();
         loop_keys.reverse();
         for i in 1..loop_keys.len() {
@@ -174,28 +115,14 @@ fn load_gradient(ini: &Ini) -> ComputableColor {
         }
     }
 
-    let steps = ini.getuint("gradient", "gradient_steps").unwrap().unwrap();
-    let mut gradient = Vec::with_capacity(steps.try_into().unwrap());
-
-    let step_size = 1.0 / (steps as f32 / (keys.len() as f32 - 1.0));
-    for i in 0..keys.len() - 1 {
-        let current = keys.get(i).unwrap();
-        let next = keys.get(i + 1).unwrap();
-
-        let mut t = 0.0;
-        while t <= 1.0 {
-            t += step_size;
-
-            let r = lerp(current.0, next.0, t);
-            let g = lerp(current.1, next.1, t);
-            let b = lerp(current.2, next.2, t);
-
-            gradient.push(Color::Rgb { r, g, b });
-        }
-    }
-
-    return ComputableColor {
-        values: gradient,
-        current: 0,
+    let steps: usize = if debug::is_debug() {
+        debug::DEBUG_COLOR_DISPLAY_SIZE * 2
+    } else {
+        ini.getuint("gradient", "gradient_steps")
+            .unwrap()
+            .unwrap()
+            .try_into()
+            .unwrap()
     };
+    return generate_gradient(keys, steps - 1);
 }