From 2c94acd52cc92dc4ebefd999dbca771367cc3090 Mon Sep 17 00:00:00 2001 From: Craig Jennings Date: Sun, 3 May 2026 16:13:21 -0500 Subject: feat(dev-fkeys): add project-aware F4 compile/run dispatcher MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit I added a new module `modules/dev-fkeys.el` that owns the dev F-key block. F4 prompts via `completing-read` with a candidate set filtered by project type (compiled / interpreted / unknown). C-F4 is the compile-only fast path. M-F4 is clean + rebuild. It runs a heuristic clean command derived from the project markers (go.mod, Cargo.toml, Eask, Makefile, CMakeLists.txt) and chains `projectile-compile-project` on success. S-F4 stays on `recompile` and now lives globally instead of duplicated across prog-general.el and prog-c.el. F6 is bound globally to `projectile-test-project` as a Phase 1 stopgap. Phase 2 replaces it with the polyglot test runner spec'd in todo.org. Project-type detection runs against the projectile root and falls back to `unknown` when no marker matches. Interpreted markers are checked first so a Python or Node project with a Makefile for tasks classifies as interpreted instead of compiled. Compile + Run sequencing uses a one-shot `compilation-finish-functions` hook that self-removes on first invocation and only fires the follow-up when the status string starts with `finished`. Cleanup in the same commit: - Dropped F4/F5/F6 from `prog-general.el`'s prog-mode-hook. They are now global. - Dropped F6→format bindings from prog-c.el / prog-python.el / prog-shell.el. C-; f was already bound in each, so this is pure removal. - Dropped the duplicate S-F4 from prog-c.el. The global binding covers it. - Updated the keybinding header in prog-general.el and the workflow comments in prog-c.el / prog-shell.el. - Wired `(require 'dev-fkeys)` in init.el alongside coverage-core. TDD: 73 tests across 11 files, one per helper. Production code is split into small testable internals (`cj/--detect-project-type`, `cj/--f4-candidates`, `cj/--f4-derive-clean-cmd`, `cj/--f4-make-once-hook`, `cj/--f4-dispatch`, `cj/--f4-compile-and-run-impl`, `cj/--f4-clean-rebuild-impl`, `cj/--f4-project-root`) plus three thin interactive wrappers. Smoke tests confirm bindings register on load. Known limitation: if another `compilation-finish-functions` hook fires between my add-hook and the compile finishing, the chain can fire on the wrong compile. The hook self-removes on first invocation regardless of which compile it sees. Documented in the impl docstring. Acceptable for v1. Phase 2 will replace F6 with the polyglot test runner (tree-sitter queries for Python/Go/TS, sexp scan for Elisp, buffer-local last-test memory). --- modules/dev-fkeys.el | 208 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 modules/dev-fkeys.el (limited to 'modules/dev-fkeys.el') diff --git a/modules/dev-fkeys.el b/modules/dev-fkeys.el new file mode 100644 index 00000000..d2c70131 --- /dev/null +++ b/modules/dev-fkeys.el @@ -0,0 +1,208 @@ +;;; dev-fkeys.el --- Developer F-key dispatchers -*- lexical-binding: t -*- + +;;; Commentary: +;; Project-aware F-key block for developer workflows: +;; +;; F4 completing-read of compile/run candidates filtered by project type +;; C-F4 fast path: compile only (no-op on interpreted projects) +;; M-F4 fast path: clean + rebuild (no-op on interpreted projects) +;; S-F4 recompile (built-in) +;; F6 project tests (Phase 1 stopgap; Phase 2 will replace with the +;; polyglot test runner spec'd in todo.org) +;; +;; Project-type detection runs against the projectile root and falls back to +;; 'unknown when no marker matches. Interpreted markers are checked before +;; compiled markers, so a Python or Node project that also has a Makefile +;; for tasks classifies as interpreted. +;; +;; F7 (coverage) is wired in coverage-core.el. F5 is reserved for the debug +;; ticket and intentionally left unbound here. + +;;; Code: + +(require 'cl-lib) + +(declare-function projectile-compile-project "projectile" (arg)) +(declare-function projectile-run-project "projectile" (arg)) +(declare-function projectile-project-root "projectile" (&optional dir)) +(declare-function projectile-test-project "projectile" (arg)) +(declare-function recompile "compile" (&optional edit-command)) + +;; ---------- Project root ---------- + +(defun cj/--f4-project-root () + "Return projectile project root, or nil. Never errors. +Some projectile configurations signal an error when called outside a +known project; this wrapper degrades to nil so the F4 dispatcher routes +to the \\='unknown branch instead of crashing." + (when (fboundp 'projectile-project-root) + (condition-case nil + (projectile-project-root) + (error nil)))) + +;; ---------- Project-type detection ---------- + +(defconst cj/--f4-interpreted-markers + '("pyproject.toml" "requirements.txt" "Pipfile" "package.json") + "Markers that classify a project as interpreted (Run-only menu).") + +(defconst cj/--f4-compiled-markers + '("go.mod" "Cargo.toml" "CMakeLists.txt" "Makefile" "Eask") + "Markers that classify a project as compiled (full Compile/Run/Clean menu).") + +(defun cj/--f4-any-marker-p (root markers) + "Return non-nil if any of MARKERS exists at ROOT." + (cl-some (lambda (m) (file-exists-p (expand-file-name m root))) markers)) + +(defun cj/--detect-project-type (root) + "Classify project at ROOT as \\='compiled, \\='interpreted, or \\='unknown. +Interpreted markers are checked before compiled markers, so a Python or +Node project that also has a Makefile for tasks classifies as interpreted. +Returns \\='unknown when ROOT is nil or no marker matches." + (cond + ((not root) 'unknown) + ((cj/--f4-any-marker-p root cj/--f4-interpreted-markers) 'interpreted) + ((cj/--f4-any-marker-p root cj/--f4-compiled-markers) 'compiled) + (t 'unknown))) + +;; ---------- Clean command derivation ---------- + +(defun cj/--f4-derive-clean-cmd (root) + "Pick a clean shell command for the project at ROOT, or nil. +First marker matched wins. ROOT may be nil; nil and a path with no +recognized markers both return nil." + (when root + (cond + ((file-exists-p (expand-file-name "go.mod" root)) "go clean ./...") + ((file-exists-p (expand-file-name "Cargo.toml" root)) "cargo clean") + ((file-exists-p (expand-file-name "Eask" root)) "eask clean") + ((file-exists-p (expand-file-name "Makefile" root)) "make clean") + ((file-exists-p (expand-file-name "CMakeLists.txt" root)) "cmake --build build --target clean")))) + +;; ---------- Action handlers ---------- + +(defun cj/--f4-compile-and-run-impl () + "Run `projectile-compile-project', then `projectile-run-project' on success. +Installs a one-shot `compilation-finish-functions' hook to chain the run." + (add-hook 'compilation-finish-functions + (cj/--f4-make-once-hook + (lambda () (projectile-run-project nil)))) + (projectile-compile-project nil)) + +(defun cj/--f4-dispatch (action) + "Route ACTION (a symbol from `cj/--f4-candidates') to its handler. +Signals `user-error' on an unrecognized symbol or nil." + (pcase action + ('compile-only (projectile-compile-project nil)) + ('run-only (projectile-run-project nil)) + ('compile-and-run (cj/--f4-compile-and-run-impl)) + ('clean-rebuild (cj/--f4-clean-rebuild-impl (cj/--f4-project-root))) + ('compile-plain (call-interactively #'compile)) + (_ (user-error "Unknown F4 action: %s" action)))) + +(defun cj/--f4-clean-rebuild-impl (root) + "Run the heuristic clean for project at ROOT, then rebuild on success. +Signals `user-error' when no clean command can be derived. The rebuild +side reuses `projectile-compile-project' so the per-project compile +command (prompted-and-cached by projectile) drives the build." + (let ((clean-cmd (cj/--f4-derive-clean-cmd root))) + (unless clean-cmd + (user-error "Clean + Rebuild: no clean command for this project type")) + (add-hook 'compilation-finish-functions + (cj/--f4-make-once-hook + (lambda () (projectile-compile-project nil)))) + (let ((default-directory root)) + (compile clean-cmd)))) + +;; ---------- One-shot compilation-finish hook ---------- + +(defun cj/--f4-make-once-hook (then-fn) + "Build a one-shot `compilation-finish-functions' hook that chains THEN-FN. +The returned lambda removes itself from `compilation-finish-functions' on +first invocation regardless of status, then calls THEN-FN only if the +status string starts with \"finished\" (the convention used by compile.el +for a successful compile)." + (let (hook) + (setq hook + (lambda (_buf status) + (remove-hook 'compilation-finish-functions hook) + (when (and (stringp status) + (string-prefix-p "finished" status)) + (funcall then-fn)))) + hook)) + +;; ---------- Candidate menus ---------- + +(defun cj/--f4-candidates (project-type) + "Return alist of (LABEL . ACTION) for the F4 menu given PROJECT-TYPE. +The first entry is the default, selected on RET in completing-read. +Compiled projects get the full menu, interpreted projects get Run only, +anything else (including nil and unrecognized symbols) falls through to +a single Compile entry that calls plain `compile'." + (pcase project-type + ('compiled '(("Compile + Run" . compile-and-run) + ("Compile" . compile-only) + ("Run" . run-only) + ("Clean + Rebuild" . clean-rebuild))) + ('interpreted '(("Run" . run-only))) + (_ '(("Compile" . compile-plain))))) + +;; ---------- Interactive wrappers ---------- + +(defun cj/f4-compile-and-run () + "Project-aware F4 dispatcher. +Prompts via `completing-read' with a candidate set filtered by project +type (compiled / interpreted / unknown), then dispatches the chosen +label's action." + (interactive) + (let* ((root (cj/--f4-project-root)) + (project-type (cj/--detect-project-type root)) + (candidates (cj/--f4-candidates project-type)) + (default (caar candidates)) + (label (completing-read + (format "F4 (%s): " project-type) + (mapcar #'car candidates) nil t nil nil default)) + (action (cdr (assoc label candidates)))) + (cj/--f4-dispatch action))) + +(defun cj/f4-compile-only () + "C-F4 fast path: compile only. +Compiled projects run `projectile-compile-project'. Interpreted projects +get a no-op message. Outside any project, falls back to interactive +`compile'." + (interactive) + (let* ((root (cj/--f4-project-root)) + (project-type (cj/--detect-project-type root))) + (pcase project-type + ('compiled (projectile-compile-project nil)) + ('interpreted (message "C-F4: not a compiled language")) + (_ (call-interactively #'compile))))) + +(defun cj/f4-clean-rebuild () + "M-F4 fast path: clean + rebuild. +Compiled projects run the heuristic clean + projectile-compile-project +chain. Interpreted projects and unrecognized projects get a no-op +message." + (interactive) + (let* ((root (cj/--f4-project-root)) + (project-type (cj/--detect-project-type root))) + (pcase project-type + ('compiled (cj/--f4-clean-rebuild-impl root)) + ('interpreted (message "M-F4: not a compiled language")) + (_ (message "M-F4: no project detected"))))) + +;; ---------- Bindings ---------- + +(keymap-global-set "" #'cj/f4-compile-and-run) +(keymap-global-set "C-" #'cj/f4-compile-only) +(keymap-global-set "M-" #'cj/f4-clean-rebuild) +(keymap-global-set "S-" #'recompile) +;; Phase 1 stopgap. Phase 2 replaces this with the polyglot test runner +;; spec'd in todo.org. Without a global F6 binding here, the per-language +;; F6→format bindings in prog-c/python/shell would have nothing to fall +;; back on after this commit drops them, leaving F6 on its useless Emacs +;; default (`2C-command'). +(keymap-global-set "" #'projectile-test-project) + +(provide 'dev-fkeys) +;;; dev-fkeys.el ends here. -- cgit v1.2.3