feat: add history + undo/redo

Author: atagen

src/cli.rs

@@ -42,6 +42,10 @@ pub enum Command {
         rm:       bool,
     },
     Dedup,
+    Undo {
+        list: bool,
+    },
+    Redo,
     Help,
 }
 
@@ -204,6 +208,22 @@ fn parse_parser(mut parser: lexopt::Parser) -> Result<Command> {
             }
             Ok(Command::Dedup)
         },
+        "undo" => {
+            let mut list = false;
+            while let Some(arg) = parser.next()? {
+                match arg {
+                    Long("list") => list = true,
+                    Short(_) | Long(_) | Value(_) => return Err(arg.unexpected().into()),
+                }
+            }
+            Ok(Command::Undo { list })
+        },
+        "redo" => {
+            if let Some(arg) = parser.next()? {
+                return Err(arg.unexpected().into());
+            }
+            Ok(Command::Redo)
+        },
         _ => Ok(Command::Help),
     }
 }

src/commands.rs

@@ -33,6 +33,7 @@ use serde_json::Value;
 
 use crate::{
     fetch,
+    history,
     lock,
     pins,
     pins::{
@@ -50,7 +51,7 @@ const STARTER_TOML: &str = include_str!("../assets/pins.toml");
 const RESOLVER_NIX: &str = include_str!("../.tack/default.nix");
 const MARKER: &str = "# tack-managed resolver.";
 
-fn dir() -> PathBuf {
+pub fn dir() -> PathBuf {
     if let Some(dir) = env::var_os("TACK_DIR") {
         return PathBuf::from(dir);
     }
@@ -61,10 +62,10 @@ fn dir() -> PathBuf {
     cwd.join(".tack")
 }
 
-fn pins_path(dir: &Path) -> PathBuf {
+pub fn pins_path(dir: &Path) -> PathBuf {
     dir.join("pins.toml")
 }
-fn lock_path(dir: &Path) -> PathBuf {
+pub fn lock_path(dir: &Path) -> PathBuf {
     dir.join("pins.lock.json")
 }
 
@@ -119,7 +120,7 @@ fn short(rev: &str) -> String {
     rev.chars().take(7).collect()
 }
 
-fn write_atomic(path: &Path, contents: &str) -> Result<()> {
+pub fn write_atomic(path: &Path, contents: &str) -> Result<()> {
     let mut tmp_str = path.as_os_str().to_owned();
     tmp_str.push(".tmp");
     let tmp = PathBuf::from(tmp_str);
@@ -1153,6 +1154,52 @@ fn pick_name(id: &str, aliases: &BTreeSet<String>) -> String {
         .unwrap_or_default()
 }
 
+pub fn undo(list: bool) -> Result<()> {
+    let dir = dir();
+    if list {
+        match history::list(&dir) {
+            Some(view) => render(&view, 0, view.rows.len().saturating_sub(1)),
+            None => println!("no history"),
+        }
+        return Ok(());
+    }
+    match history::undo(&dir)? {
+        Some(view) => render_window(&view),
+        None => println!("nothing to undo"),
+    }
+    Ok(())
+}
+
+pub fn redo() -> Result<()> {
+    match history::redo(&dir())? {
+        Some(view) => render_window(&view),
+        None => println!("nothing to redo"),
+    }
+    Ok(())
+}
+
+/// a radius-1 window around the new cursor: the redo target, the live state,
+/// the undo target. fewer lines at the ends.
+fn render_window(view: &history::View) {
+    let lo = view.cursor.saturating_sub(1);
+    let hi = (view.cursor + 1).min(view.rows.len().saturating_sub(1));
+    render(view, lo, hi);
+}
+
+/// rows `lo..=hi` newest-first, relative times aligned, `>` marking the cursor
+fn render(view: &history::View, lo: usize, hi: usize) {
+    let now = history::now();
+    let times = (lo..=hi)
+        .map(|idx| history::rel_time(now, view.rows[idx].ts))
+        .collect::<Vec<String>>();
+    let width = times.iter().map(String::len).max().unwrap_or(0);
+    for idx in (lo..=hi).rev() {
+        let marker = if idx == view.cursor { '>' } else { ' ' };
+        let when = &times[idx - lo];
+        println!("{marker} {when:width$}  {}", view.rows[idx].label);
+    }
+}
+
 pub fn help() {
     println!(
         "tack: flake-like toml nix pins, lazily fetched and transformed
@@ -1167,6 +1214,8 @@ usage:
   tack rm <name>
   tack alias <name> <template> | tack alias --rm <name>
   tack dedup
+  tack undo [--list]
+  tack redo
 
 pin types: flake (default), fetch (source tree only), fixed (FOD)