✨ color theme support relative and absolute date coloring (#1167)

Author: zwpaper

Cargo.lock

@@ -36,6 +36,7 @@ sys-locale = "0.3"
 once_cell = "1.21"
 chrono = { version = "0.4", features = ["unstable-locales"] }
 chrono-humanize = "0.2"
+jiff = "0.2"
 # incompatible with v0.1.11
 unicode-width = "0.2"
 lscolors = "0.21.0"

Cargo.toml

@@ -7,6 +7,7 @@ pub use crate::flags::color::ThemeOption;
 use crate::git::GitStatus;
 use crate::print_output;
 use crate::theme::{Theme, color::ColorTheme};
+use jiff::{Span, SpanTotal, Timestamp, ToSpan, Unit};
 
 #[allow(dead_code)]
 #[derive(Hash, Debug, Eq, PartialEq, Clone)]
@@ -45,9 +46,8 @@ pub enum Elem {
     System,
 
     /// Last Time Modified
-    DayOld,
-    HourOld,
-    Older,
+    Date(i64),
+    InvalidDate,
 
     /// User / Group Name
     User,
@@ -123,10 +123,6 @@ impl Elem {
             Elem::Hidden => theme.attributes.hidden,
             Elem::System => theme.attributes.system,
 
-            Elem::DayOld => theme.date.day_old,
-            Elem::HourOld => theme.date.hour_old,
-            Elem::Older => theme.date.older,
-
             Elem::User => theme.user,
             Elem::Group => theme.group,
             Elem::NonFile => theme.size.none,
@@ -169,15 +165,30 @@ impl Elem {
             Elem::GitStatus {
                 status: GitStatus::Conflicted,
             } => theme.git_status.conflicted,
+            Elem::Date(_) | Elem::InvalidDate => {
+                // These are handled in style_default, not here
+                Color::Blue
+            }
         }
     }
 }
 
 pub type ColoredString = StyledContent<String>;
 
+/// Unified timestamp-based date color entry
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct TimestampColorEntry {
+    timestamp: i64,
+    color: Color,
+}
+
 pub struct Colors {
     theme: Option<ColorTheme>,
     lscolors: Option<LsColors>,
+    default_date_color: Color,
+    /// Sorted timestamp table: all entries (legacy, relative, absolute) converted to timestamps
+    /// Sorted in ascending order (oldest first)
+    timestamp_colors: Vec<TimestampColorEntry>,
 }
 
 impl Colors {
@@ -209,7 +220,72 @@ impl Colors {
             _ => None,
         };
 
-        Self { theme, lscolors }
+        let (default_date_color, timestamp_colors) = if let Some(t) = &theme {
+            let now = Timestamp::now().as_second();
+            let mut timestamp_entries: Vec<TimestampColorEntry> = Vec::new();
+
+            // Convert legacy config to timestamp entries (relative to now)
+            if let Some(hour_old) = t.date.hour_old {
+                timestamp_entries.push(TimestampColorEntry {
+                    timestamp: now - 1.hours().total(Unit::Second).unwrap() as i64,
+                    color: hour_old,
+                });
+            }
+
+            if let Some(day_old) = t.date.day_old {
+                timestamp_entries.push(TimestampColorEntry {
+                    timestamp: now
+                        - 1.days()
+                            .total(SpanTotal::from(Unit::Second).days_are_24_hours())
+                            .unwrap() as i64,
+                    color: day_old,
+                });
+            }
+
+            timestamp_entries.push(TimestampColorEntry {
+                timestamp: i64::MIN,
+                color: t.date.older,
+            });
+
+            // Convert relative config to timestamp entries
+            for relative in &t.date.relative {
+                if let Ok(span) = relative.threshold.parse::<Span>() {
+                    if let Ok(total_seconds) =
+                        span.total(SpanTotal::from(Unit::Second).days_are_24_hours())
+                    {
+                        let timestamp = now - total_seconds as i64;
+                        timestamp_entries.push(TimestampColorEntry {
+                            timestamp,
+                            color: relative.color,
+                        })
+                    }
+                }
+            }
+
+            // Convert absolute config to timestamp entries
+            for absolute in &t.date.absolute {
+                if let Ok(threshold) = absolute.threshold.parse::<Timestamp>() {
+                    timestamp_entries.push(TimestampColorEntry {
+                        timestamp: threshold.as_second(),
+                        color: absolute.color,
+                    });
+                }
+            }
+
+            // Sort by timestamp (descending order - newest first)
+            timestamp_entries.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
+
+            (t.date.older, timestamp_entries)
+        } else {
+            (Color::Blue, Vec::new())
+        };
+
+        Self {
+            theme,
+            lscolors,
+            default_date_color,
+            timestamp_colors,
+        }
     }
 
     pub fn colorize<S: Into<String>>(&self, input: S, elem: &Elem) -> ColoredString {
@@ -250,7 +326,30 @@ impl Colors {
 
     fn style_default(&self, elem: &Elem) -> ContentStyle {
         if let Some(t) = &self.theme {
-            let style_fg = ContentStyle::default().with(elem.get_color(t));
+            let color = match elem {
+                Elem::Date(timestamp) => {
+                    let mut color = self.default_date_color;
+
+                    for entry in &self.timestamp_colors {
+                        if *timestamp >= entry.timestamp {
+                            color = entry.color;
+                            break;
+                        }
+                    }
+
+                    color
+                }
+                Elem::InvalidDate => {
+                    // For invalid dates, use the oldest color if available, otherwise default
+                    self.timestamp_colors
+                        .last()
+                        .map(|e| e.color)
+                        .unwrap_or(self.default_date_color)
+                }
+                _ => elem.get_color(t),
+            };
+
+            let style_fg = ContentStyle::default().with(color);
             if elem.has_suid() {
                 style_fg.on(Color::AnsiValue(124)) // Red3
             } else {
@@ -439,9 +538,11 @@ mod elem {
                 special: Color::AnsiValue(44),      // DarkTurquoise
             },
             date: color::Date {
-                hour_old: Color::AnsiValue(40), // Green3
-                day_old: Color::AnsiValue(42),  // SpringGreen2
-                older: Color::AnsiValue(36),    // DarkCyan
+                hour_old: Some(Color::AnsiValue(40)), // Green3
+                day_old: Some(Color::AnsiValue(42)),  // SpringGreen2
+                older: Color::AnsiValue(36),          // DarkCyan
+                relative: Vec::new(),
+                absolute: Vec::new(),
             },
             size: color::Size {
                 none: Color::AnsiValue(245),   // Grey

src/color.rs

@@ -33,16 +33,14 @@ impl From<&Metadata> for Date {
 
 impl Date {
     pub fn render(&self, colors: &Colors, flags: &Flags) -> ColoredString {
-        let now = Local::now();
-        #[allow(deprecated)]
+        let date_string = self.date_string(flags);
         let elem = match self {
-            &Date::Date(modified) if modified > now - Duration::hours(1) => Elem::HourOld,
-            &Date::Date(modified) if modified > now - Duration::days(1) => Elem::DayOld,
-            &Date::Date(_) | Date::Invalid => Elem::Older,
+            Self::Date(modified) => Elem::Date(modified.timestamp()),
+            Self::Invalid => Elem::InvalidDate,
         };
-        colors.colorize(self.date_string(flags), &elem)
-    }
 
+        colors.colorize(date_string, &elem)
+    }
     fn date_string(&self, flags: &Flags) -> String {
         let locale = current_locale();