magdalena

fzf.zig (18965B)

---

 const std = @import("std");
 
 const cache = @import("memcached.zig");
 const cfg = @import("cfg.zig");
 const hist = @import("db.zig");
 const io = @import("io.zig");
 
 fn gotoFile(allocator: std.mem.Allocator, db: ?*hist.Db, file_path: []const u8, line: ?[]const u8, config: *const cfg.Config) !void {
     const ext = if (std.mem.lastIndexOfScalar(u8, file_path, '.')) |idx| file_path[idx + 1 ..] else "";
 
     var action: []const u8 = "text_editor";
     var command: ?[]const u8 = null;
 
     for (config.openers) |opener| {
         for (opener.extensions) |e| {
             if (std.mem.eql(u8, e, ext)) {
                 action = opener.action;
                 command = opener.command;
                 break;
             }
         }
         if (command != null) break;
     }
 
     if (db) |d| {
         d.logFile(file_path, ext, action) catch |err| io.warn("failed to log file: {}\n", .{err});
     }
 
     if (std.Io.Dir.openFileAbsolute(io.rt(), "/dev/tty", .{ .mode = .read_write })) |tty| {
         if (std.c.dup2(tty.handle, std.posix.STDIN_FILENO) < 0) io.warn("failed to redirect stdin to tty\n", .{});
         if (std.c.dup2(tty.handle, std.posix.STDOUT_FILENO) < 0) io.warn("failed to redirect stdout to tty\n", .{});
         tty.close(io.rt());
     } else |err| {
         io.warn("failed to open /dev/tty: {}\n", .{err});
     }
 
     if (command) |cmd| {
         return std.process.replace(io.rt(), .{ .argv = &.{ cmd, file_path } });
     }
 
     const editor = config.editor orelse (io.getenv("EDITOR") orelse return error.EditorNotSet);
 
     if (line) |l| {
         const line_arg = try std.fmt.allocPrint(allocator, "+{s}", .{l});
         return std.process.replace(io.rt(), .{ .argv = &.{ editor, line_arg, file_path } });
     }
 
     return std.process.replace(io.rt(), .{ .argv = &.{ editor, file_path } });
 }
 
 const StdIo = std.process.SpawnOptions.StdIo;
 
 const Fzf = struct {
     argv: [][]const u8,
     allocator: std.mem.Allocator,
     stdin: StdIo = .pipe,
     stdout: StdIo = .pipe,
     stderr: StdIo = .inherit,
 
     pub fn init(allocator: std.mem.Allocator, fzf_opts: []const []const u8, extra_opts: []const []const u8) !Fzf {
         var argv = try allocator.alloc([]const u8, 1 + fzf_opts.len + extra_opts.len);
         errdefer allocator.free(argv);
 
         var i: usize = 0;
         argv[i] = "fzf";
         i += 1;
         for (fzf_opts) |opt| {
             argv[i] = opt;
             i += 1;
         }
         for (extra_opts) |opt| {
             argv[i] = opt;
             i += 1;
         }
 
         return .{
             .argv = argv,
             .allocator = allocator,
         };
     }
 
     pub fn spawn(self: *Fzf) !std.process.Child {
         return std.process.spawn(io.rt(), .{
             .argv = self.argv,
             .stdin = self.stdin,
             .stdout = self.stdout,
             .stderr = self.stderr,
         });
     }
 
     pub fn deinit(self: *Fzf) void {
         self.allocator.free(self.argv);
     }
 };
 
 // ignored_patterns entries are matched by exact path component name, not globs.
 fn shouldSkip(path: []const u8, ignored_patterns: []const []const u8) bool {
     var it = std.mem.splitScalar(u8, path, std.fs.path.sep);
     while (it.next()) |component| {
         for (ignored_patterns) |pattern| {
             if (std.mem.eql(u8, component, pattern)) {
                 return true;
             }
         }
     }
     return false;
 }
 
 fn runFzfPicker(allocator: std.mem.Allocator, fzf_opts: []const []const u8, items: []const []const u8) ![]u8 {
     var fzf = try Fzf.init(allocator, fzf_opts, &[_][]const u8{});
     defer fzf.deinit();
     var child = try fzf.spawn();
 
     if (child.stdin) |stdin| {
         for (items) |item| {
             stdin.writeStreamingAll(io.rt(), item) catch |err| {
                 if (err == error.BrokenPipe) break;
                 return err;
             };
             stdin.writeStreamingAll(io.rt(), "\n") catch |err| {
                 if (err == error.BrokenPipe) break;
                 return err;
             };
         }
         stdin.close(io.rt());
         child.stdin = null;
     }
 
     var stdout_data: ?[]u8 = null;
     defer if (stdout_data) |d| allocator.free(d);
 
     if (child.stdout) |stdout| {
         var buffer: [4096]u8 = undefined;
         var sr = stdout.reader(io.rt(), &buffer);
         stdout_data = try sr.interface.allocRemaining(allocator, .unlimited);
     }
 
     const term = try child.wait(io.rt());
     if (term != .exited or term.exited != 0) return error.UserAbort;
     const selected = std.mem.trim(u8, stdout_data orelse "", " \n\r\t");
     if (selected.len == 0) return error.UserAbort;
 
     return allocator.dupe(u8, selected);
 }
 
 pub fn recentDir(allocator: std.mem.Allocator, db: *hist.Db, config: *const cfg.Config) !void {
     const managed_dirs = try db.recentDirs();
     defer managed_dirs.deinit();
     const dirs = managed_dirs.value;
 
     if (dirs.len == 0) {
         io.warn("No recent directories found.\n", .{});
         return;
     }
 
     var items = std.ArrayListUnmanaged([]const u8).empty;
     defer items.deinit(allocator);
 
     for (dirs) |dir| {
         if (shouldSkip(dir.path, config.ignored_patterns)) continue;
         try items.append(allocator, dir.path);
     }
 
     const selected = try runFzfPicker(allocator, config.fzf_opts, items.items);
     defer allocator.free(selected);
 
     std.Io.Dir.accessAbsolute(io.rt(), selected, .{}) catch |err| {
         io.warn("Selected directory no longer exists: {s} ({})\n", .{ selected, err });
         return error.UserAbort;
     };
 
     var out_buf: [4096]u8 = undefined;
     var out = io.getStdout(&out_buf);
     try out.print("{s}\n", .{selected});
     try out.end();
 }
 
 pub fn favorites(allocator: std.mem.Allocator, db: *hist.Db, config: *const cfg.Config) !void {
     if (config.favorites.len == 0) {
         io.warn("No favorites found in config.\n", .{});
         return;
     }
 
     var items = std.ArrayListUnmanaged([]const u8).empty;
     defer {
         for (items.items) |item| allocator.free(item);
         items.deinit(allocator);
     }
 
     for (config.favorites) |entry| {
         const expanded = try expandPath(allocator, entry);
         try items.append(allocator, expanded);
     }
 
     const selected = try runFzfPicker(allocator, config.fzf_opts, items.items);
     defer allocator.free(selected);
 
     const is_dir = blk: {
         var dir = std.Io.Dir.openDirAbsolute(io.rt(), selected, .{}) catch break :blk false;
         dir.close(io.rt());
         break :blk true;
     };
 
     if (is_dir) {
         try db.logDir(selected);
         var out_buf: [4096]u8 = undefined;
         var out = io.getStdout(&out_buf);
         try out.print("{s}\n", .{selected});
         try out.end();
     } else {
         try gotoFile(allocator, db, selected, null, config);
     }
 }
 
 fn expandPath(allocator: std.mem.Allocator, path: []const u8) ![]const u8 {
     var res = std.ArrayListUnmanaged(u8).empty;
     errdefer res.deinit(allocator);
 
     var i: usize = 0;
     while (i < path.len) {
         if (std.mem.startsWith(u8, path[i..], "$HOME")) {
             const home = io.getenv("HOME") orelse "/home/user";
             try res.appendSlice(allocator, home);
             i += 5;
         } else {
             try res.append(allocator, path[i]);
             i += 1;
         }
     }
 
     return res.toOwnedSlice(allocator);
 }
 
 pub fn recentFile(allocator: std.mem.Allocator, db: *hist.Db, config: *const cfg.Config) !void {
     const managed_files = try db.recentFiles();
     defer managed_files.deinit();
     const files = managed_files.value;
 
     if (files.len == 0) {
         io.warn("No recent files found.\n", .{});
         return;
     }
 
     var items = std.ArrayListUnmanaged([]const u8).empty;
     defer items.deinit(allocator);
 
     for (files) |file| {
         if (shouldSkip(file.path, config.ignored_patterns)) continue;
         try items.append(allocator, file.path);
     }
 
     const selected = try runFzfPicker(allocator, config.fzf_opts, items.items);
     defer allocator.free(selected);
 
     try std.Io.Dir.accessAbsolute(io.rt(), selected, .{});
 
     try gotoFile(allocator, db, selected, null, config);
 }
 
 pub fn grep(allocator: std.mem.Allocator, db: *hist.Db, config: *const cfg.Config) !void {
     const initial_query = "";
 
     var rg_cmd = std.ArrayListUnmanaged(u8).empty;
     defer rg_cmd.deinit(allocator);
     try rg_cmd.appendSlice(allocator, "change:reload:rg --column --line-number --no-heading --color=always --smart-case");
     for (config.ignored_patterns) |pattern| {
         try rg_cmd.appendSlice(allocator, " --glob '!");
         try rg_cmd.appendSlice(allocator, pattern);
         try rg_cmd.appendSlice(allocator, "/*'");
         try rg_cmd.appendSlice(allocator, " --glob '!");
         try rg_cmd.appendSlice(allocator, pattern);
         try rg_cmd.appendSlice(allocator, "'");
     }
     try rg_cmd.appendSlice(allocator, " {q} || true");
 
     var fzf = try Fzf.init(allocator, config.fzf_opts, &[_][]const u8{
         "--disabled",
         "--query",
         initial_query,
         "--bind",
         rg_cmd.items,
         "--delimiter",
         ":",
         "--preview",
         "bat --highlight-line {2} {1}",
         "--preview-window",
         "right,60%,border-left,+{2}+3/3,~3",
     });
     defer fzf.deinit();
 
     fzf.stdin = .inherit;
     fzf.stdout = .pipe;
     fzf.stderr = .inherit;
 
     var child = try fzf.spawn();
 
     var stdout_data: ?[]u8 = null;
     defer if (stdout_data) |d| allocator.free(d);
 
     if (child.stdout) |stdout| {
         var buffer: [4096]u8 = undefined;
         var sr = stdout.reader(io.rt(), &buffer);
         stdout_data = try sr.interface.allocRemaining(allocator, .unlimited);
     }
 
     const term = try child.wait(io.rt());
     if (term != .exited or term.exited != 0) return error.UserAbort;
     const selected = std.mem.trim(u8, stdout_data orelse "", " \n\r\t");
     if (selected.len == 0) return error.UserAbort;
 
     var it = std.mem.splitScalar(u8, selected, ':');
     if (it.next()) |file| {
         const line = it.next();
         try gotoFile(allocator, db, file, line, config);
     }
 }
 
 pub fn lookFile(allocator: std.mem.Allocator, db: *hist.Db, config: *const cfg.Config, depth: ?usize) !void {
     try runFzfWithWalker(allocator, db, .file, config, depth);
 }
 
 pub fn lookDir(allocator: std.mem.Allocator, db: *hist.Db, config: *const cfg.Config, depth: ?usize) !void {
     try runFzfWithWalker(allocator, db, .directory, config, depth);
 }
 
 const Entry = struct {
     path: []const u8,
     mtime: i128,
 };
 
 fn getMaxDirMtime(ignored_patterns: []const []const u8, max_depth: usize) !i128 {
     var max_mtime: i128 = 0;
 
     if (std.Io.Dir.cwd().statFile(io.rt(), ".", .{})) |stat| {
         max_mtime = stat.mtime.nanoseconds;
     } else |_| {}
 
     var root = try std.Io.Dir.cwd().openDir(io.rt(), ".", .{ .iterate = true });
     defer root.close(io.rt());
     try scanMaxMtime(&root, 0, max_depth, ignored_patterns, &max_mtime);
 
     return max_mtime;
 }
 
 // Recurses one open directory per call frame, so each handle is closed exactly
 // once by its own `defer` as the recursion unwinds.
 fn scanMaxMtime(dir: *std.Io.Dir, depth: usize, max_depth: usize, ignored_patterns: []const []const u8, max_mtime: *i128) !void {
     var it = dir.iterate();
     while (try it.next(io.rt())) |entry| {
         var skip = false;
         for (ignored_patterns) |pattern| {
             if (std.mem.eql(u8, entry.name, pattern)) {
                 skip = true;
                 break;
             }
         }
         if (skip) continue;
 
         const is_dir = entry.kind == .directory;
         if (is_dir or entry.kind == .sym_link) {
             const stat = dir.statFile(io.rt(), entry.name, .{}) catch |err| {
                 if (err != error.FileNotFound and err != error.AccessDenied) {
                     io.warn("failed to stat {s}: {}\n", .{ entry.name, err });
                 }
                 continue;
             };
             if (stat.kind == .directory) {
                 if (stat.mtime.nanoseconds > max_mtime.*) max_mtime.* = stat.mtime.nanoseconds;
 
                 if (is_dir and depth + 1 < max_depth) {
                     var sub_dir = dir.openDir(io.rt(), entry.name, .{ .iterate = true }) catch |err| {
                         io.warn("failed to open directory {s}: {}\n", .{ entry.name, err });
                         continue;
                     };
                     defer sub_dir.close(io.rt());
                     try scanMaxMtime(&sub_dir, depth + 1, max_depth, ignored_patterns, max_mtime);
                 }
             }
         }
     }
 }
 
 // Recurses one open directory per call frame (closed by its own `defer`),
 // collecting matching entries with their path relative to the walk root.
 fn collectEntries(
     allocator: std.mem.Allocator,
     dir: *std.Io.Dir,
     prefix: ?[]const u8,
     depth: usize,
     max_depth: usize,
     kind: std.Io.File.Kind,
     ignored_patterns: []const []const u8,
     entries: *std.ArrayListUnmanaged(Entry),
 ) !void {
     var it = dir.iterate();
     while (try it.next(io.rt())) |entry| {
         const entry_path = if (prefix) |p|
             try std.fs.path.join(allocator, &.{ p, entry.name })
         else
             try allocator.dupe(u8, entry.name);
         defer allocator.free(entry_path);
 
         if (shouldSkip(entry_path, ignored_patterns)) continue;
 
         if (entry.kind == kind or entry.kind == .sym_link) {
             if (dir.statFile(io.rt(), entry.name, .{})) |stat| {
                 if (stat.kind == kind) {
                     try entries.append(allocator, .{
                         .path = try allocator.dupe(u8, entry_path),
                         .mtime = stat.mtime.nanoseconds,
                     });
                 }
             } else |err| {
                 if (err != error.FileNotFound and err != error.AccessDenied) {
                     io.warn("failed to stat {s}: {}\n", .{ entry.name, err });
                 }
             }
         }
 
         if (entry.kind == .directory and depth + 1 < max_depth) {
             var sub_dir = dir.openDir(io.rt(), entry.name, .{ .iterate = true }) catch |err| {
                 io.warn("failed to open directory {s}: {}\n", .{ entry.name, err });
                 continue;
             };
             defer sub_dir.close(io.rt());
             try collectEntries(allocator, &sub_dir, entry_path, depth + 1, max_depth, kind, ignored_patterns, entries);
         }
     }
 }
 
 fn runFzfWithWalker(allocator: std.mem.Allocator, db: *hist.Db, kind: std.Io.File.Kind, config: *const cfg.Config, depth: ?usize) !void {
     const is_dir = kind == .directory;
     const max_depth = depth orelse config.max_depth;
 
     var entries = std.ArrayListUnmanaged(Entry).empty;
     defer {
         for (entries.items) |e| allocator.free(e.path);
         entries.deinit(allocator);
     }
 
     var mc = cache.Memcached.init(allocator, "127.0.0.1", 11211) catch |err| blk: {
         if (err != error.ConnectionRefused) {
             io.warn("failed to initialize memcached: {}\n", .{err});
         }
         break :blk null;
     };
     defer if (mc) |*m| m.deinit();
 
     var cache_key: ?[]const u8 = null;
     defer if (cache_key) |k| allocator.free(k);
 
     var cache_hit = false;
     if (mc) |*m| {
         const cwd = blk: {
             break :blk std.process.currentPathAlloc(io.rt(), allocator) catch |err| {
                 io.warn("failed to get cwd for cache: {}\n", .{err});
                 break :blk null;
             };
         };
         if (cwd) |c| {
             defer allocator.free(c);
 
             const hash = std.hash.Crc32.hash(c);
             const max_dir_mtime = getMaxDirMtime(config.ignored_patterns, max_depth) catch blk: {
                 break :blk @as(i128, 0);
             };
             const mtime = @divTrunc(max_dir_mtime, std.time.ns_per_s);
             cache_key = try std.fmt.allocPrint(allocator, "magdalena:look:{s}:{x}:{d}:{d}", .{ if (is_dir) "dir" else "file", hash, mtime, max_depth });
             if (cache_key) |key| {
                 const cached_data = try m.get(key);
                 if (cached_data) |data| {
                     defer allocator.free(data);
                     const parsed = try std.json.parseFromSlice([]Entry, allocator, data, .{});
                     defer parsed.deinit();
                     for (parsed.value) |e| {
                         try entries.append(allocator, .{
                             .path = try allocator.dupe(u8, e.path),
                             .mtime = e.mtime,
                         });
                     }
                     cache_hit = true;
                 }
             }
         }
     }
 
     if (!cache_hit) {
         var root = try std.Io.Dir.cwd().openDir(io.rt(), ".", .{ .iterate = true });
         defer root.close(io.rt());
         try collectEntries(allocator, &root, null, 0, max_depth, kind, config.ignored_patterns, &entries);
 
         if (mc) |*m| {
             if (cache_key) |key| {
                 const json_data = try std.json.Stringify.valueAlloc(allocator, entries.items, .{});
                 defer allocator.free(json_data);
                 try m.set(key, json_data, 3600);
             }
         }
     }
 
     std.mem.sortUnstable(Entry, entries.items, {}, struct {
         fn lessThan(_: void, a: Entry, b: Entry) bool {
             return a.mtime > b.mtime;
         }
     }.lessThan);
 
     var items = std.ArrayListUnmanaged([]const u8).empty;
     defer items.deinit(allocator);
     for (entries.items) |entry| {
         try items.append(allocator, entry.path);
     }
 
     const selected = try runFzfPicker(allocator, config.fzf_opts, items.items);
     defer allocator.free(selected);
 
     const clean_path = if (std.mem.startsWith(u8, selected, "./")) selected[2..] else selected;
 
     if (clean_path.len > 0) {
         std.Io.Dir.cwd().access(io.rt(), clean_path, .{}) catch |err| {
             io.warn("Selected item no longer exists or is inaccessible: {s} ({})\n", .{ clean_path, err });
             return error.UserAbort;
         };
         if (is_dir) {
             var out_buf: [4096]u8 = undefined;
             var out = io.getStdout(&out_buf);
             try out.print("{s}\n", .{clean_path});
             try out.end();
         } else {
             try gotoFile(allocator, db, clean_path, null, config);
         }
     }
 }
 
 const testing = std.testing;
 
 test "shouldSkip: matches an exact path component" {
     const ignored = [_][]const u8{ "node_modules", ".git" };
     try testing.expect(shouldSkip("src/node_modules/pkg/x.js", &ignored));
     try testing.expect(shouldSkip(".git/config", &ignored));
     try testing.expect(shouldSkip("a/b/.git", &ignored));
 }
 
 test "shouldSkip: partial component is not a match" {
     const ignored = [_][]const u8{"node_modules"};
     try testing.expect(!shouldSkip("src/lib/main.zig", &ignored));
     try testing.expect(!shouldSkip("src/node_modules_old/x", &ignored));
 }
 
 test "shouldSkip: empty pattern set never skips" {
     try testing.expect(!shouldSkip("a/b/c", &.{}));
 }