use chrono::{Datelike, Duration, NaiveDate, NaiveTime, Timelike};
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, sync::OnceLock};
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Config {
pub last_date: String,
pub last_branch: String,
pub last_message: String,
#[serde(default)]
pub accounts: Vec<crate::accounts::Account>,
#[serde(default)]
pub active_account: Option<String>,
#[serde(default)]
pub original: Option<crate::accounts::Original>,
pub theme: Theme,
pub keys: KeyMap,
}
fn default_true() -> bool {
true
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(default)]
pub struct Theme {
pub accent: Option<String>,
pub show_header: bool,
pub show_mascot: bool,
pub show_subtitle: bool,
}
impl Default for Theme {
fn default() -> Self {
Theme {
accent: None,
show_header: default_true(),
show_mascot: default_true(),
show_subtitle: default_true(),
}
}
}
impl Theme {
pub fn accent_rgb(&self) -> Option<(u8, u8, u8)> {
let raw = self.accent.as_deref()?.trim();
let hex = raw.strip_prefix('#').unwrap_or(raw);
if hex.len() != 6 || !hex.bytes().all(|b| b.is_ascii_hexdigit()) {
return None;
}
let n = |i: usize| u8::from_str_radix(&hex[i..i + 2], 16).ok();
Some((n(0)?, n(2)?, n(4)?))
}
}
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(transparent)]
pub struct KeyMap(pub HashMap<String, Vec<String>>);
impl KeyMap {
pub fn extra_for(&self, action: &str) -> Vec<char> {
let Some(keys) = self.0.get(action) else {
return Vec::new();
};
keys.iter()
.filter_map(|key| {
let mut chars = key.chars();
match (chars.next(), chars.next()) {
(Some(c), None) if !c.is_control() && !c.is_whitespace() => Some(c),
_ => None,
}
})
.collect()
}
}
#[derive(Clone, Debug)]
pub struct Values {
pub date: String,
pub time: String,
pub branch: String,
pub message: String,
pub amend: bool,
pub dry_run: bool,
}
pub fn initial_values(config: Config, branch: &str) -> Values {
let (date, time) = config
.last_date
.split_once(' ')
.map_or((String::new(), String::new()), |(date, time)| {
(date.into(), time.into())
});
Values {
date,
time,
branch: if config.last_branch.is_empty() {
branch.into()
} else {
config.last_branch
},
message: config.last_message,
amend: false,
dry_run: false,
}
}
pub fn valid_date(value: &str) -> bool {
let parts: Vec<_> = value.split('-').collect();
if parts.len() != 3 || parts[0].len() != 4 || parts[1].len() != 2 || parts[2].len() != 2 {
return false;
}
let Ok(year) = parts[0].parse::<i32>() else {
return false;
};
let Ok(month) = parts[1].parse::<u32>() else {
return false;
};
let Ok(day) = parts[2].parse::<u32>() else {
return false;
};
if !(1..=12).contains(&month) || day == 0 {
return false;
}
let leap = year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
let days = [
31,
if leap { 29 } else { 28 },
31,
30,
31,
30,
31,
31,
30,
31,
30,
31,
];
day <= days[(month - 1) as usize]
}
pub fn valid_time(value: &str) -> bool {
let parts: Vec<_> = value.split(':').collect();
if parts.len() != 3 || parts.iter().any(|part| part.len() != 2) {
return false;
}
let Ok(hour) = parts[0].parse::<u32>() else {
return false;
};
let Ok(minute) = parts[1].parse::<u32>() else {
return false;
};
let Ok(second) = parts[2].parse::<u32>() else {
return false;
};
hour < 24 && minute < 60 && second < 60
}
pub fn first_problem(values: &Values) -> Option<&'static str> {
if !valid_date(&values.date) {
Some("Please set a valid date")
} else if !valid_time(&values.time) {
Some("Please set a valid time (HH:MM:SS)")
} else if values.branch.trim().is_empty() {
Some("Please choose a branch")
} else if values.message.trim().is_empty() {
Some("Please write a commit message")
} else {
None
}
}
pub fn preview(value: &str, max: usize) -> String {
truncate(&value.split_whitespace().collect::<Vec<_>>().join(" "), max)
}
pub fn current_year() -> String {
chrono::Local::now().year().to_string()
}
pub fn truncate(value: &str, max: usize) -> String {
if value.chars().count() > max {
format!("{}…", value.chars().take(max - 1).collect::<String>())
} else {
value.into()
}
}
pub fn with_bullets(message: &str, list: &str) -> String {
let list = list.trim();
let items: Vec<&str> = if list.contains('\n') {
list.lines().collect()
} else if list.starts_with("- ") || list.contains(" - ") {
list.split(" - ").collect()
} else {
split_compact(list)
};
let bullets: Vec<String> = items
.iter()
.map(|item| item.trim())
.map(|item| {
item.strip_prefix('-')
.filter(|rest| !rest.starts_with('-'))
.unwrap_or(item)
.trim()
})
.filter(|item| !item.is_empty())
.map(|item| format!("- {item}"))
.collect();
if bullets.is_empty() {
message.trim().into()
} else {
format!("{}\n\n{}", message.trim(), bullets.join("\n"))
}
}
fn split_compact(list: &str) -> Vec<&str> {
let bytes = list.as_bytes();
let mut starts: Vec<usize> = (0..bytes.len())
.filter(|&i| {
bytes[i] == b'-'
&& (i == 0 || bytes[i - 1].is_ascii_whitespace())
&& bytes.get(i + 1) != Some(&b'-')
})
.collect();
if starts.first() != Some(&0) {
starts.insert(0, 0);
}
starts.push(bytes.len());
starts.windows(2).map(|w| &list[w[0]..w[1]]).collect()
}
static KEYMAP: OnceLock<KeyMap> = OnceLock::new();
pub fn set_keymap(map: KeyMap) {
let _ = KEYMAP.set(map);
}
pub fn extra_keys(action: &str) -> Vec<char> {
KEYMAP.get().map(|k| k.extra_for(action)).unwrap_or_default()
}
pub fn adjust(values: &mut Values, row: usize, delta: i32, branches: &[String]) -> bool {
if delta == 0 {
return false;
}
let step: i64 = if delta < 0 { -1 } else { 1 };
match row {
0 => {
let base = parse_date(&values.date).unwrap_or_else(|| chrono::Local::now().date_naive());
match base.checked_add_signed(Duration::days(step)) {
Some(d) => {
values.date = d.format("%Y-%m-%d").to_string();
true
}
None => false,
}
}
1 => {
values.time = shift_minute(&values.time, step);
true
}
2 => {
if branches.is_empty() {
return false;
}
let next = match branches.iter().position(|b| *b == values.branch) {
Some(i) => (i as i64 + step).rem_euclid(branches.len() as i64) as usize,
None if step < 0 => branches.len() - 1,
None => 0,
};
let changed = values.branch != branches[next];
values.branch = branches[next].clone();
changed
}
5 => {
let cur = values.amend as i64 + 2 * values.dry_run as i64;
let next = (cur + step).rem_euclid(4);
values.amend = next & 1 != 0;
values.dry_run = next & 2 != 0;
true
}
_ => false,
}
}
fn parse_date(value: &str) -> Option<NaiveDate> {
if valid_date(value) {
NaiveDate::parse_from_str(value, "%Y-%m-%d").ok()
} else {
None
}
}
fn parse_time(value: &str) -> Option<NaiveTime> {
if valid_time(value) {
NaiveTime::parse_from_str(value, "%H:%M:%S").ok()
} else {
None
}
}
fn shift_minute(current: &str, step: i64) -> String {
let t = parse_time(current).unwrap_or_else(|| chrono::Local::now().time());
let minutes = (t.hour() as i64 * 60 + t.minute() as i64 + step).rem_euclid(1440);
format!("{:02}:{:02}:{:02}", minutes / 60, minutes % 60, t.second())
}
fn day_shift(current: &str, days: i64) -> Option<String> {
let base = parse_date(current).unwrap_or_else(|| chrono::Local::now().date_naive());
let d = base.checked_add_signed(Duration::days(days))?;
Some(d.format("%Y-%m-%d").to_string())
}
pub fn preset_date(key: char, current: &str) -> Option<String> {
match key {
'n' => Some(chrono::Local::now().format("%Y-%m-%d").to_string()),
'y' => day_shift("", -1),
'-' => day_shift(current, -1),
'+' => day_shift(current, 1),
_ => None,
}
}
pub fn preset_time(key: char, current: &str) -> Option<String> {
match key {
'n' => Some(chrono::Local::now().format("%H:%M:%S").to_string()),
'r' => Some(random_time_between(9, 18)),
'-' => Some(shift_minute(current, -1)),
'+' => Some(shift_minute(current, 1)),
_ => None,
}
}
pub fn random_time_between(lo_hour: u32, hi_hour: u32) -> String {
let (a, b) = (lo_hour.min(23), hi_hour.min(23));
let (lo, hi) = (a.min(b) as u64 * 3600, a.max(b) as u64 * 3600);
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_nanos() as u64);
let mut x = nanos.wrapping_add(0x9E37_79B9_7F4A_7C15);
x = (x ^ (x >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
x = (x ^ (x >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
x ^= x >> 31;
let secs = lo + x % (hi - lo + 1);
format!("{:02}:{:02}:{:02}", secs / 3600, secs / 60 % 60, secs % 60)
}
#[cfg(test)]
mod tests {
use super::*;
fn vals(date: &str, time: &str) -> Values {
Values {
date: date.into(),
time: time.into(),
branch: "main".into(),
message: String::new(),
amend: false,
dry_run: false,
}
}
#[test]
fn date_adjust() {
let mut v = vals("2024-02-28", "");
assert!(adjust(&mut v, 0, 1, &[]));
assert_eq!(v.date, "2024-02-29");
adjust(&mut v, 0, 1, &[]);
assert_eq!(v.date, "2024-03-01");
let mut v = vals("2023-02-28", "");
adjust(&mut v, 0, 1, &[]);
assert_eq!(v.date, "2023-03-01");
let mut v = vals("2024-12-31", "");
adjust(&mut v, 0, 1, &[]);
assert_eq!(v.date, "2025-01-01");
adjust(&mut v, 0, -1, &[]);
assert_eq!(v.date, "2024-12-31");
let mut v = vals("", "");
assert!(adjust(&mut v, 0, 1, &[]));
assert!(valid_date(&v.date));
let mut v = vals("garbage", "");
assert!(adjust(&mut v, 0, -1, &[]));
assert!(valid_date(&v.date));
}
#[test]
fn time_adjust() {
let mut v = vals("", "23:59:42");
adjust(&mut v, 1, 1, &[]);
assert_eq!(v.time, "00:00:42");
adjust(&mut v, 1, -1, &[]);
assert_eq!(v.time, "23:59:42");
let mut v = vals("", "");
assert!(adjust(&mut v, 1, 1, &[]));
assert!(valid_time(&v.time));
}
#[test]
fn branch_and_options() {
let b: Vec<String> = ["main", "dev", "x"].iter().map(|s| s.to_string()).collect();
let mut v = vals("", "");
assert!(adjust(&mut v, 2, 1, &b));
assert_eq!(v.branch, "dev");
adjust(&mut v, 2, 1, &b);
adjust(&mut v, 2, 1, &b);
assert_eq!(v.branch, "main");
adjust(&mut v, 2, -1, &b);
assert_eq!(v.branch, "x");
v.branch = "other".into();
assert!(adjust(&mut v, 2, 1, &b));
assert_eq!(v.branch, "main");
v.branch = "other".into();
assert!(adjust(&mut v, 2, -1, &b));
assert_eq!(v.branch, "x");
assert!(!adjust(&mut v, 2, 1, &[]));
let mut v = vals("", "");
let mut seen = vec![];
for _ in 0..4 {
adjust(&mut v, 5, 1, &[]);
seen.push((v.amend, v.dry_run));
}
assert_eq!(
seen,
[(true, false), (false, true), (true, true), (false, false)]
);
adjust(&mut v, 5, -1, &[]);
assert_eq!((v.amend, v.dry_run), (true, true));
assert!(!adjust(&mut v, 3, 1, &b));
assert!(!adjust(&mut v, 4, 1, &b));
}
#[test]
fn presets() {
assert_eq!(preset_date('+', "2024-02-28").unwrap(), "2024-02-29");
assert_eq!(preset_date('-', "2024-01-01").unwrap(), "2023-12-31");
assert!(valid_date(&preset_date('n', "").unwrap()));
assert!(valid_date(&preset_date('y', "").unwrap()));
assert!(preset_date('q', "").is_none());
assert_eq!(preset_time('+', "23:59:07").unwrap(), "00:00:07");
assert_eq!(preset_time('-', "00:00:07").unwrap(), "23:59:07");
assert!(valid_time(&preset_time('n', "").unwrap()));
assert!(preset_time('z', "").is_none());
}
#[test]
fn random_in_window() {
for _ in 0..200 {
let t = random_time_between(9, 18);
assert!(valid_time(&t));
assert!(t.as_str() >= "09:00:00" && t.as_str() <= "18:00:00", "{t}");
}
assert_eq!(random_time_between(5, 5), "05:00:00");
assert!(valid_time(&preset_time('r', "").unwrap()));
}
#[test]
fn config_compat() {
let c: Config = serde_json::from_str("{}").unwrap();
assert!(c.theme.show_header && c.theme.show_mascot && c.theme.show_subtitle);
assert!(c.keys.0.is_empty());
let c: Config = serde_json::from_str(
r#"{"last_date":"2024-01-01 10:00:00","last_branch":"main","last_message":"m"}"#,
)
.unwrap();
assert_eq!(c.last_branch, "main");
assert!(c.theme.accent.is_none());
let c: Config = serde_json::from_str(r##"{"theme":{"accent":"#12ab9F"}}"##).unwrap();
assert_eq!(c.theme.accent_rgb(), Some((0x12, 0xab, 0x9f)));
assert!(c.theme.show_header);
}
#[test]
fn accent_validation() {
let t = |s: &str| Theme {
accent: Some(s.into()),
..Theme::default()
};
assert_eq!(t("ff0000").accent_rgb(), Some((255, 0, 0)));
for bad in ["#ggg000", "#fff", "#1234567", "", "#", "##123456", "#12345é"] {
assert_eq!(t(bad).accent_rgb(), None, "{bad}");
}
assert_eq!(Theme::default().accent_rgb(), None);
}
#[test]
fn reserved_keys() {
let mut m = KeyMap::default();
m.0.insert(
"up".into(),
[
"k", "Enter", "esc", "Esc", "Up", "ctrl-c", "c-c", "C-c", "", " ", "jj", "J",
]
.iter()
.map(|s| s.to_string())
.collect(),
);
assert_eq!(m.extra_for("up"), vec!['k', 'J']);
assert!(m.extra_for("down").is_empty());
}
#[test]
fn global_keymap() {
assert!(extra_keys("up").is_empty());
let mut m = KeyMap::default();
m.0.insert("quit".into(), vec!["x".into()]);
set_keymap(m);
set_keymap(KeyMap::default());
assert_eq!(extra_keys("quit"), vec!['x']);
}
#[test]
fn bullets() {
let b = |list| with_bullets("feat: x", list);
assert_eq!(
b("-integrate login -integrate log-in"),
"feat: x\n\n- integrate login\n- integrate log-in"
);
assert_eq!(b(" "), "feat: x");
assert_eq!(
b("- commit with -d -t without the TUI - gct --agent prints it"),
"feat: x\n\n- commit with -d -t without the TUI\n- gct --agent prints it"
);
assert_eq!(b("-a uses -d\n\t- b"), "feat: x\n\n- a uses -d\n- b");
assert_eq!(
b("-run gct --agent -ünï"),
"feat: x\n\n- run gct --agent\n- ünï"
);
assert_eq!(b("no dash -two"), "feat: x\n\n- no dash\n- two");
assert_eq!(b("- a - --push pushes"), "feat: x\n\n- a\n- --push pushes");
assert_eq!(b("--push first\n- b"), "feat: x\n\n- --push first\n- b");
}
}