Dim picker

Author: SofusA

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pathmarks"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2024"
 description = "Simple path bookmarks for your shell"
 license = "MIT"

Cargo.toml

@@ -25,7 +25,7 @@ pub fn init(shell: Shell, command: Option<String>) -> String {
 end
 
 
-function {command}i'
+function {command}i
     while true
         set -l dest (pathmarks pick)
         set -l code $status

src/init.rs

@@ -5,17 +5,17 @@ use std::path::{Path, PathBuf};
 use std::{env, io};
 
 use clap::{Parser, Subcommand};
-use nucleo_picker::Picker;
 use nucleo_picker::nucleo::pattern::{CaseMatching, Normalization, Pattern};
 use nucleo_picker::nucleo::{Config, Matcher};
 
 use crate::error::{AppError, AppResult};
-use crate::index_renderer::IndexPathRenderer;
 use crate::init::{Shell, init};
+use crate::pickers::{pick_one, pick_one_last_dim};
 
 mod error;
 mod index_renderer;
 mod init;
+mod pickers;
 
 #[derive(Parser)]
 #[command(name = "pathmarks")]
@@ -133,9 +133,14 @@ fn app(cli: Cli, bookmarks_file: PathBuf) -> AppResult<Option<String>> {
             Ok(Some(out.join("\n")))
         }
         Cmd::Pick => {
-            let directories = merged_directories(bookmarks_file)?;
+            let bookmarks = read_bookmarks(&bookmarks_file)?;
+            let current_dir = env::current_dir()?;
+
+            let relative_bookmarks = map_relative_paths(&current_dir, bookmarks);
+            let sub_directories = list_child_dirs(&current_dir, false)?;
+            let relative_sub_directories = map_relative_paths(&current_dir, sub_directories);
 
-            match pick_one(&directories)? {
+            match pick_one_last_dim(&relative_sub_directories, &relative_bookmarks)? {
                 Some(bookmark) => Ok(bookmark.to_str().map(|x| x.into())),
                 None => Ok(None),
             }
@@ -149,23 +154,8 @@ fn merged_directories(bookmarks_file: PathBuf) -> AppResult<Vec<PathBuf>> {
     let merged_directories = merge_with_cwd_dirs(bookmarks)?;
 
     let cwd = env::current_dir()?;
-    let mut out = Vec::with_capacity(merged_directories.len());
-
-    for path in merged_directories {
-        if let Some(relative) = relative_if_descendant(&cwd, &path) {
-            if let Some(s) = relative.to_str() {
-                if s != "." {
-                    out.push(s.into());
-                }
-            } else {
-                out.push(path);
-            }
-        } else {
-            out.push(path);
-        }
-    }
 
-    Ok(out)
+    Ok(map_relative_paths(&cwd, merged_directories))
 }
 
 fn best_bookmark_match<'a>(
@@ -250,16 +240,6 @@ fn is_absolute(p: &str) -> bool {
     Path::new(p).is_absolute()
 }
 
-fn pick_one(bookmarks: &[PathBuf]) -> AppResult<Option<&PathBuf>> {
-    let mut picker = Picker::new(IndexPathRenderer::new(bookmarks));
-    let mut injector = picker.injector();
-    injector.extend(0..bookmarks.len());
-
-    let selected_idx = picker.pick()?.copied();
-
-    Ok(selected_idx.map(|i| &bookmarks[i]))
-}
-
 fn list_child_dirs(dir: &Path, include_hidden: bool) -> io::Result<Vec<PathBuf>> {
     let mut out = Vec::new();
 
@@ -333,6 +313,16 @@ fn relative_if_descendant(base: &Path, child: &Path) -> Option<PathBuf> {
         .ok()
 }
 
+fn map_relative_paths<I>(base: &Path, paths: I) -> Vec<PathBuf>
+where
+    I: IntoIterator<Item = PathBuf>,
+{
+    paths
+        .into_iter()
+        .map(|p| relative_if_descendant(base, &p).unwrap_or(p))
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/main.rs

@@ -0,0 +1,78 @@
+use std::path::PathBuf;
+
+use nucleo_picker::{Picker, Render};
+
+use crate::{error::AppResult, index_renderer::IndexPathRenderer};
+
+pub fn pick_one(bookmarks: &[PathBuf]) -> AppResult<Option<&PathBuf>> {
+    let mut picker = Picker::new(IndexPathRenderer::new(bookmarks));
+    let mut injector = picker.injector();
+    injector.extend(0..bookmarks.len());
+
+    let selected_idx = picker.pick()?.copied();
+
+    Ok(selected_idx.map(|i| &bookmarks[i]))
+}
+
+#[derive(Clone, Copy)]
+enum Source {
+    First,
+    Second,
+}
+
+struct Entry<'a> {
+    path: &'a PathBuf,
+    source: Source,
+}
+
+pub fn pick_one_last_dim<'a>(
+    first: &'a [PathBuf],
+    second: &'a [PathBuf],
+) -> AppResult<Option<&'a PathBuf>> {
+    let entries: Vec<Entry<'a>> = first
+        .iter()
+        .map(|p| Entry {
+            path: p,
+            source: Source::First,
+        })
+        .chain(second.iter().map(|p| Entry {
+            path: p,
+            source: Source::Second,
+        }))
+        .collect();
+
+    let renderer = DualListIndexRenderer { entries: &entries };
+
+    let mut picker = Picker::new(renderer);
+    let mut injector = picker.injector();
+
+    injector.extend(0..entries.len());
+
+    let selected_idx = picker.pick()?.copied();
+    Ok(selected_idx.map(|i| entries[i].path))
+}
+
+pub struct DualListIndexRenderer<'a> {
+    entries: &'a [Entry<'a>],
+}
+
+impl<'a> Render<usize> for DualListIndexRenderer<'a> {
+    type Str<'b>
+        = String
+    where
+        usize: 'b;
+
+    fn render<'b>(&self, idx: &'b usize) -> Self::Str<'b> {
+        let entry = &self.entries[*idx];
+        let path = entry.path.to_string_lossy();
+
+        const ITALIC: &str = "\x1b[3m";
+        const DIM: &str = "\x1b[2m";
+        const RESET: &str = "\x1b[0m";
+
+        match entry.source {
+            Source::First => path.to_string(),
+            Source::Second => format!("{DIM}{ITALIC}{path}{RESET}"),
+        }
+    }
+}