diff options
| author | Eugene Triguba <hello@eugenetriguba.com> | 2026-04-04 09:53:30 -0400 |
|---|---|---|
| committer | Eugene Triguba <hello@eugenetriguba.com> | 2026-04-04 09:53:30 -0400 |
| commit | d4f4658766b35f81a36966734b5aaf74f5ad80f6 (patch) | |
| tree | 0aaa0224ba3e0a5024cdc242e86db6d23a4cf35e | |
| parent | Add lisp mode comment to sbclrc and remove swank autostart (diff) | |
| download | dotfiles-d4f4658766b35f81a36966734b5aaf74f5ad80f6.zip | |
Add find-file-in-project.el dependency to emacs
| -rw-r--r-- | .emacs.d/init.el | 5 | ||||
| -rw-r--r-- | .emacs.d/vendor/find-file-in-project.el | 1568 |
2 files changed, 1572 insertions, 1 deletions
diff --git a/.emacs.d/init.el b/.emacs.d/init.el index e728f6e..6996359 100644 --- a/.emacs.d/init.el +++ b/.emacs.d/init.el @@ -17,8 +17,11 @@ ;; * Loads each module in the necessary order. ;; ;;; Code: -(add-to-list 'load-path '"~/.emacs.d/modules") +(add-to-list 'load-path "~/.emacs.d/vendor") +(require 'find-file-in-project) +(setq ffip-use-rust-fd t) +(add-to-list 'load-path "~/.emacs.d/modules") (require 'et-package) (require 'et-appearance) (require 'et-vc) diff --git a/.emacs.d/vendor/find-file-in-project.el b/.emacs.d/vendor/find-file-in-project.el new file mode 100644 index 0000000..24fedce --- /dev/null +++ b/.emacs.d/vendor/find-file-in-project.el @@ -0,0 +1,1568 @@ +;;; find-file-in-project.el --- Find file/directory and review Diff/Patch/Commit efficiently -*- lexical-binding: t -*- + +;; Copyright (C) 2006-2009, 2011-2012, 2015-2018 +;; Phil Hagelberg, Doug Alcorn, Will Farrington, Chen Bin +;; +;; Version: 6.2.5 +;; Author: Phil Hagelberg, Doug Alcorn, and Will Farrington +;; Maintainer: Chen Bin <chenbin.sh@gmail.com> +;; URL: https://github.com/redguardtoo/find-file-in-project +;; Package-Requires: ((emacs "25.1")) +;; Created: 2008-03-18 +;; Keywords: project, convenience +;; EmacsWiki: FindFileInProject + +;; This file is NOT part of GNU Emacs. + +;;; License: + +;; This program is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 3, or (at your option) +;; any later version. +;; +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. +;; +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Commentary: + +;; This program provides methods to find file in project. +;; +;; Features, +;; - Only dependency is BSD/GNU find +;; - Works on Windows with minimum setup +;; - Works on Tramp Mode (https://www.emacswiki.org/emacs/TrampMode) +;; - fd (faster alternative of find, see https://github.com/sharkdp/fd) is supported +;; - Uses native API `completing-read' and supports helm/ivy/consult/selectrum out of box. +;; +;; Helm setup, +;; (helm-mode 1) +;; +;; Ivy setup, +;; (ivy-mode 1) +;; +;; Ido setup, +;; (setq ffip-prefer-ido-mode t) +;; +;; Usage, +;; - You can insert "(setq ffip-use-rust-fd t)" into ".emacs" to use fd (alternative of find) +;; - `find-file-in-project-at-point' guess the file path at point and +;; find file +;; - `find-file-in-project-by-selected' uses the selected region +;; as the keyword to search file. You can provide the keyword +;; if no region is selected. +;; - `find-directory-in-project-by-selected' uses the select region +;; to find directory. You can provide the keyword if no region +;; is selected. +;; - `find-file-in-project' starts search file immediately +;; - `ffip-create-project-file' creates ".dir-locals.el" +;; - `ffip-lisp-find-file-in-project' finds file in project. +;; If its parameter is not nil, it find directory. +;; This command is written in pure Lisp and does not use any third party +;; command line program. So it works in all environments. +;; +;; A project is found by searching up the directory tree until a file +;; is found that matches `ffip-project-file'. +;; You can set `ffip-project-root-function' to provide an alternate +;; function to search for the project root. By default, it looks only +;; for files whose names match `ffip-patterns', + +;; If you have so many files that it becomes unwieldy, you can set +;; `ffip-find-options' to a string which will be passed to the `find' +;; invocation in order to exclude irrelevant subdirectories/files. +;; For instance, in a Ruby on Rails project, you are interested in all +;; .rb files that don't exist in the "vendor" directory. In that case +;; you could set `ffip-find-options' to "-not -regex \".*vendor.*\"". + +;; `ffip-insert-file' insert file content into current buffer. + +;; `find-file-with-similar-name' find file with similar name to current +;; opened file. The regular expression `ffip-strip-file-name-regex' is +;; also used by `find-file-with-similar-name'. +;; +;; all these variables may be overridden on a per-directory basis in +;; your ".dir-locals.el". See (info "(Emacs) Directory Variables") for +;; details. +;; +;; Sample ".dir-locals.el", +;; +;; ((nil . ((ffip-project-root . "~/projs/PROJECT_DIR") +;; ;; ignore files bigger than 64k and directory "dist/" when searching +;; (ffip-find-options . "-not -size +64k -not -iwholename '*/dist/*'") +;; ;; only search files with following extensions +;; (ffip-patterns . ("*.html" "*.js" "*.css" "*.java" "*.xml" "*.js")) +;; (eval . (progn +;; (require 'find-file-in-project) +;; ;; ignore directory ".tox/" when searching +;; (setq ffip-prune-patterns `("*/.tox" ,@ffip-prune-patterns)) + ;; ignore BMP image file +;; (setq ffip-ignore-filenames `("*.bmp" ,@ffip-ignore-filenames)) +;; ;; Do NOT ignore directory "bin/" when searching +;; (setq ffip-prune-patterns `(delete "*/bin" ,@ffip-prune-patterns)))) +;; ))) +;; +;; To find in current directory, use `find-file-in-current-directory' +;; and `find-file-in-current-directory-by-selected'. +;; +;; `ffip-fix-file-path-at-point' replaces path at point with correct relative/absolute path. +;; The path can be cleaned up by `ffip-fix-file-path-at-point-strip-regex'. +;; +;; File/directory searching actions are automatically stored into `ffip-find-files-history'. +;; Use `ffip-find-files-resume' to replay any previous action. +;; The maximum number of items of the history is set in `ffip-find-files-history-max-items'. +;; +;; `ffip-show-diff' execute the backend from `ffip-diff-backends'. +;; The output is in Unified Diff Format and inserted into *ffip-diff* buffer. +;; Press "o" or "C-c C-c" or "ENTER" or `M-x ffip-diff-find-file' in the +;; buffer to open corresponding file. Please note some backends assume that the git cli program +;; is added into environment variable PATH. +;; +;; `ffip-diff-find-file-before-hook' is called in `ffip-diff-find-file'. +;; Two file names are passed to it as parameters. One name is returned by the hook +;; as the file searching keyword. +;; +;; `ffip-diff-apply-hunk' applies current hunk in `diff-mode' (please note +;; `ffip-diff-mode' inherits from `diff-mode') to the target. +;; file. The target file could be located by searching `recentf-list'. +;; Except this extra feature, `ffip-diff-apply-hunk' is same as `diff-apply-hunk'. +;; So `diff-apply-hunk' can be replaced by `ffip-diff-apply-hunk'. +;; +;; `ffip-diff-filter-hunks-by-file-name' can filter hunks by their file names. +;; User input pattern "regex !exclude1 exclude1" means the hunk's file name does match "regex". +;; But does not match "exclude1" or "exclude2".; +;; Please note in "regex", space represents any string. +;; +;; If you use `evil-mode', insert below code into ~/.emacs, +;; (defun ffip-diff-mode-hook-setup () +;; (evil-local-set-key 'normal "K" 'diff-hunk-prev) +;; (evil-local-set-key 'normal "J" 'diff-hunk-next) +;; (evil-local-set-key 'normal "P" 'diff-file-prev) +;; (evil-local-set-key 'normal "N" 'diff-file-next) +;; (evil-local-set-key 'normal (kbd "RET") 'ffip-diff-find-file) +;; (evil-local-set-key 'normal "o" 'ffip-diff-find-file)) +;; (add-hook 'ffip-diff-mode-hook 'ffip-diff-mode-hook-setup) + +;; `find-relative-path' find file/directory and copy its relative path +;; into `kill-ring'. You can customize `ffip-find-relative-path-callback' +;; to format the relative path, +;; (setq ffip-find-relative-path-callback 'ffip-copy-reactjs-import) +;; (setq ffip-find-relative-path-callback 'ffip-copy-org-file-link) +;; +;; BSD/GNU Find can be installed through Cygwin or MYSYS2 on Windows. +;; Executable is automatically detected. But you can manually specify +;; the executable location by insert below code into ".emacs", +;; +;; (if (eq system-type 'windows-nt) +;; (setq ffip-find-executable "c:\\\\cygwin64\\\\bin\\\\find")) +;; +;; This program works on Windows/Cygwin/Linux/macOS +;; +;; See https://github.com/redguardtoo/find-file-in-project for advanced tips. + +;;; Code: + +(require 'find-file) +(require 'find-lisp) +(require 'diff-mode) +(require 'windmove) +(require 'subr-x) +(require 'ido) + +(defgroup ffip nil + "Find File in Project." + :group 'convenience) + +(defcustom ffip-use-rust-fd nil + "Use rust fd instead of GNU find." + :link '(url-link :tag "fd @ GitHub" + "https://github.com/sharkdp/fd") + :group 'ffip + :type 'boolean + :safe #'booleanp) + +(defcustom ffip-rust-fd-executable-name "fd" + "Rust fd executable name." + :group 'ffip + :type 'string) + +(defcustom ffip-gnu-find-executable-name "find" + "GNU find executable name." + :group 'ffip + :type 'string) + +(defcustom ffip-rust-fd-respect-ignore-files t + "Don't show search results from '.*ignore' files." + :group 'ffip + :type 'boolean + :safe #'booleanp) + +(defcustom ffip-project-search-function 'ffip-project-search-default-function + "Function to execute find program in shell." + :group 'ffip + :type 'function + :safe #'functionp) + +(defcustom ffip-prefer-ido-mode nil + "Prefer `ido-completing-read' to filter file candidates." + :group 'ffip + :type 'boolean + :safe #'booleanp) + +(defcustom ffip-rust-fd-extra-opts "" + "Rust fd extra options passed to cli." + :group 'ffip + :type 'string) + +(defcustom ffip-diff-find-file-by-file-name-p nil + "When find file in diff hunk, only search by file name." + :group 'ffip + :type 'boolean + :safe #'booleanp) + +(defcustom ffip-strip-file-name-regex + "\\(\\.mock\\|\\.test\\|\\.mockup\\)" + "Strip file name to get minimum keyword with this regex. +It's used by `find-file-with-similar-name'." + :group 'ffip + :type 'regexp) + +(defcustom ffip-fix-file-path-at-point-strip-regex + "\\(/index\\.[jt]sx?\\|\\.[jt]sx?\\)$" + "Strip file path with this regex. Used by `ffip-fix-file-path-at-point'." + :group 'ffip + :type 'regexp) + +(defcustom ffip-find-files-history-max-items 4 + "Maximum number of items stored in `ffip-find-files-history'. +If this number is zero, no item is saved into `ffip-find-files-history'." + :group 'ffip + :type 'integer) + +(defvar ffip-filename-history nil + "History of file names provided by users.") + +(defvar ffip-find-files-history nil + "History generated by `ffip-find-files'.") + +(defvar ffip-diff-find-file-before-hook nil + "Hook before `ffip-diff-find-file' move focus out of *ffip-diff* buffer.") + +(defvar ffip-read-file-name-hijacked-p nil + "Internal flag used by `ffip-diff-apply-hunk'.") + +(defvar ffip-diff-apply-hunk-hook nil + "Hook when `ffip-diff-apply-hunk' find the file to apply hunk. +The file path is passed to the hook as the first argument.") + +(defvar ffip-relative-path-pattern "^\\(\\.\\.*/\\)+" + "Pattern of relative path.") + +(defun ffip-nonempty-lines (str) + "Return non empty lines from STR." + (split-string str "[\r\n]+" t)) + +(defun ffip-diff-git-versions () + "List all versions of code under Git." + (let* ((cmd1 "git branch --no-color --all") + (cmd2 (concat "git --no-pager log --date=short --pretty=format:'%h|%ad|%s|%an'" buffer-file-name))) + (nconc (ffip-nonempty-lines (shell-command-to-string cmd1)) + (ffip-nonempty-lines (shell-command-to-string cmd2))))) + +(defun ffip-diff-select-version () + "Select a version from git history." + (let* ((line (completing-read "Select from git history: " (ffip-diff-git-versions))) + (version (replace-regexp-in-string "^ *\\*? *" + "" + (car (split-string line "|" t))))) + version)) + +;;;###autoload +(defun ffip-git-diff-current-file () + "Compare another version of current file." + (let* ((default-directory (locate-dominating-file default-directory ".git"))) + (shell-command-to-string (format "git --no-pager diff %s:%s %s" + (ffip-diff-select-version) + (file-relative-name buffer-file-name default-directory) + buffer-file-name)))) + +(defun ffip-git-diff-project() + "Compare another version of project." + (let* ((default-directory (locate-dominating-file default-directory ".git"))) + (shell-command-to-string (format "git --no-pager diff %s" + (ffip-diff-select-version))))) + +(defun ffip-git-diff-directory() + "Compare another version of current directory." + (when buffer-file-name + (let* ((dir (read-directory-name "Directory: " (file-name-directory buffer-file-name))) + (default-directory (locate-dominating-file default-directory ".git"))) + (shell-command-to-string (format "git --no-pager diff %s -- \"%s\"" + (ffip-diff-select-version) + dir))))) + +(defun ffip-git-diff-file-extension() + "Compare another version of files matching file extensions from user input. +File extensions are separated by space character." + (let* ((patterns (read-string "File extensions (e.g., \"cpp py\" matches C++ and Python code files): " + (and buffer-file-name (file-name-extension buffer-file-name))))) + (when patterns + (let* ((default-directory (locate-dominating-file default-directory ".git"))) + (setq patterns + (mapconcat (lambda (s) (format "\"*.%s\"" s)) (split-string patterns " +") " ")) + (shell-command-to-string (format "git --no-pager diff %s -- %s" + (ffip-diff-select-version) + patterns)))))) + +(defvar ffip-diff-backends + '(ffip-git-diff-current-file + ffip-git-diff-project + ffip-git-diff-directory + ffip-git-diff-file-extension + ("`git diff HEAD^` in project" . "cd $(git rev-parse --show-toplevel) && git diff HEAD^") + ("`git diff --cached` in project" . "cd $(git rev-parse --show-toplevel) && git diff --cached") + ("`git diff` in project" . "cd $(git rev-parse --show-toplevel) && git diff") + ("`git diff` current file" . (shell-command-to-string (format "cd $(git rev-parse --show-toplevel) && git diff \"%s\"" + (buffer-file-name)))) + ;; git option "--cc" shows changes in merge commits + ("`git log -p` current file" . (shell-command-to-string (format "cd $(git rev-parse --show-toplevel) && git --no-pager log --date=short -p --cc \"%s\"" + (buffer-file-name)))) + ("`git log -S keyword -p` in project" . (shell-command-to-string (format "cd $(git rev-parse --show-toplevel) && git --no-pager log --date=short -S\"%s\" -p --cc" + (read-string "Git search string: ")))) + ("Diff from `kill-ring'" . (car kill-ring))) + "The list of back-ends. +If back-end is string, it's run in `shell-command-to-string'. +If it's a function or expression, it'll be executed and return a string. + +The output is inserted into *ffip-diff* buffer.") + +(defcustom ffip-find-executable nil + "Path of GNU find. If nil we will guess." + :group 'ffip + :type 'string) + +(defcustom ffip-project-file '(".svn" ".hg" ".git") + "The file/directory used to locate project root. +May be set using .dir-locals.el. Checks each entry if set to a list." + :group 'ffip + :type '(repeat string)) + +(defcustom ffip-patterns nil + "List of glob patterns to look for with `find-file-in-project'." + :group 'ffip + :type '(repeat string)) + +(defvar ffip-match-path-instead-of-filename nil + "Match full path instead of file name.") + +;; For "GNU/BSD Find", "*/test/*" matches "./test/" and "./dir/test/" +;; +;; But for "rust fd", only "test/*" matches "./test/" and "./dir/test/"; +;; "*/test/*" won't match "./test/" but matches "./dir/test/" +;; Maybe it's a fd bug. +(defcustom ffip-prune-patterns + '(;; VCS + "*/.git" + "*/.svn" + "*/.cvs" + "*/.tox" + "*/.bzr" + "*/.hg" + "*/.DS_Store" + "*/.sass-cache" + "*/elpy" + "*/dcache" + "*/.npm" + "*/.tmp" + "*/.idea" + "*/node_modules" + "*/bower_components" + "*/.gradle" + "*/.cask") + "Ignored directories(prune patterns)." + :group 'ffip + :type '(repeat string)) + +(defcustom ffip-ignore-filenames + '(;; VCS + ;; project misc + "*.log" + ;; Ctags + "tags" + "TAGS" + ;; compressed + "*.tgz" + "*.gz" + "*.xz" + "*.zip" + "*.tar" + "*.rar" + ;; Global/Cscope + "GTAGS" + "GPATH" + "GRTAGS" + "cscope.files" + ;; html/javascript/css + "*bundle.js" + "*min.js" + "*min.css" + ;; Images + "*.png" + "*.jpg" + "*.jpeg" + "*.gif" + "*.bmp" + "*.tiff" + "*.ico" + ;; documents + "*.doc" + "*.docx" + "*.xls" + "*.ppt" + "*.odt" + ;; C/C++ + "*.obj" + "*.so" + "*.o" + "*.a" + "*.ifso" + "*.tbd" + "*.dylib" + "*.lib" + "*.d" + "*.dll" + "*.exe" + ;; Java + ".metadata*" + "*.class" + "*.war" + "*.jar" + ;; Emacs/Vim + "*flymake" + "#*#" + ".#*" + "*.swp" + "*~" + "*.elc" + ;; Python + "*.pyc") + "Ignored file names. Wildcast is supported." + :group 'ffip + :type '(repeat string)) + +(defcustom ffip-find-options "" + "Extra options to pass to `find' when using `find-file-in-project'. + +Use this to exclude portions of your project: \"-not -regex \\\".*svn.*\\\"\"." + :group 'ffip + :type 'string) + +(defcustom ffip-find-pre-path-options "" + "Options for find program. + +GNU Find requires '-H', '-L', '-P', '-D' and `-O' appear before first path '.'. +For example, use '-L' to follow symbolic links." + :group 'ffip + :type 'string) + +(defcustom ffip-project-root nil + "If non-nil, overrides the project root directory location." + :group 'ffip + :type 'string) + +(defcustom ffip-project-root-function nil + "If non-nil, this function is called to determine the project root. +This overrides variable `ffip-project-root' when set." + :group 'ffip + :type 'function) + +(defvar ffip-debug nil "Print debug information.") + +;;;###autoload +(defun ffip-copy-without-change (p) + "Copy P without change." + (kill-new p) + (message "%s => kill-ring" p)) + +;;;###autoload +(defun ffip-copy-reactjs-import(p) + "Create ReactJS link from P and copy the result." + (setq p (format "import str from '%s';" p)) + (kill-new p) + (message "%s => kill-ring" p)) + +;;;###autoload +(defun ffip-copy-org-file-link(p) + "Create org link from P and copy the result." + (setq p (format "[[file:%s]]" p)) + (kill-new p) + (message "%s => kill-ring" p)) + +;;;###autoload +(defcustom ffip-find-relative-path-callback 'ffip-copy-without-change + "The callback after calling `find-relative-path'." + :group 'ffip + :type 'function) + +(defun ffip--some (predicate seq) + "Return if PREDICATE is t for any element of SEQ." + (let* (elem rlt) + (while (and (setq elem (car seq)) + (not rlt)) + (setq seq (cdr seq)) + (setq rlt (funcall predicate elem))) + rlt)) + +;;;###autoload +(defun ffip-project-root () + "Return project root or `default-directory'." + (let* ((project-root (or ffip-project-root + (cond + ((functionp ffip-project-root-function) + (funcall ffip-project-root-function)) + ((listp ffip-project-file) + (ffip--some (apply-partially 'locate-dominating-file + default-directory) + ffip-project-file)) + (t + (locate-dominating-file default-directory + ffip-project-file)))))) + (or (and project-root (file-name-as-directory project-root)) + default-directory))) + +(defun ffip--read-file-text (file) + "Read text from FILE." + (read (decode-coding-string + (with-temp-buffer + (set-buffer-multibyte nil) + (setq buffer-file-coding-system 'binary) + (insert-file-contents-literally file) + (buffer-substring-no-properties (point-min) (point-max))) 'utf-8))) + +;;;###autoload +(defun ffip-get-project-root-directory () + "Get the full path of project root directory." + (if ffip-project-root (file-name-as-directory ffip-project-root) + (ffip-project-root))) + +;;;###autoload +(defun ffip-filename-identity (keyword) + "Return identical KEYWORD." + keyword) + +;;;###autoload +(defun ffip-filename-camelcase-to-dashes (keyword &optional check-only) + "Convert KEYWORD from camel cased to dash separated. +If CHECK-ONLY is true, only do the check." + (let* (rlt) + (cond + (check-only + (setq rlt (string-match "^[a-z0-9]+[A-Z][A-Za-z0-9]+$" keyword)) + (if ffip-debug (message "ffip-filename-camelcase-to-dashes called. check-only keyword=%s rlt=%s" keyword rlt))) + (t + (let* ((case-fold-search nil)) + ;; case sensitive replace + (setq rlt (downcase (replace-regexp-in-string "\\([a-z]\\)\\([A-Z]\\)" "\\1-\\2" keyword)))) + + (if (string= rlt (downcase keyword)) (setq rlt nil)) + + (if (and rlt ffip-debug) (message "ffip-filename-camelcase-to-dashes called. rlt=%s" rlt)))) + rlt)) + +;;;###autoload +(defun ffip-filename-dashes-to-camelcase (keyword &optional check-only) + "Convert KEYWORD from dash separated to camel cased. +If CHECK-ONLY is true, only do the check." + (let* (rlt) + (cond + (check-only + (setq rlt (string-match "^[A-Za-z0-9]+\\(-[A-Za-z0-9]+\\)+$" keyword)) + (if ffip-debug (message "ffip-filename-dashes-to-camelcase called. check-only keyword=%s rlt=%s" keyword rlt))) + (t + (setq rlt (mapconcat (lambda (s) (capitalize s)) (split-string keyword "-") "")) + + (let ((first-char (substring rlt 0 1))) + (setq rlt (concat "[" first-char (downcase first-char) "]" (substring rlt 1)))) + (if (and rlt ffip-debug) (message "ffip-filename-dashes-to-camelcase called. rlt=%s" rlt)))) + rlt)) + +(defun ffip--create-filename-pattern-for-gnufind (keyword) + "Create search pattern from KEYWORD." + (let* ((rlt "")) + (cond + ((not keyword) + (setq rlt "")) + (t + (setq rlt (concat (if ffip-match-path-instead-of-filename "-iwholename" "-iname") + " \"*" + keyword + "*\"" )))) + (if ffip-debug (message "ffip--create-filename-pattern-for-gnufind called. rlt=%s" rlt)) + rlt)) + +(defun ffip--win-executable-find (exe) + "Find EXE on windows." + (let* ((drivers '("c" "d" "e" "g" "h" "i" "j" "k")) + (i 0) + j + (dirs '(":\\\\cygwin64\\\\bin\\\\" + ":\\\\cygwin-portable\\\\cygwin\\\\bin\\\\" + ":\\\\msys64\\\\usr\\\\bin\\\\")) + rlt) + (while (and (not rlt) + (< i (length dirs))) + (setq j 0) + (while (and (not rlt) + (< j (length drivers))) + (setq rlt (executable-find (concat (nth j drivers) (nth i dirs) exe))) + (setq j (1+ j))) + (setq i (1+ i))) + (unless rlt + ;; nothing found, fall back to exe + (setq rlt exe)) + rlt)) + +(defun ffip--executable-find () + "Find EXE on all environments." + (let* ((exe (if ffip-use-rust-fd ffip-rust-fd-executable-name + ffip-gnu-find-executable-name)) + rlt) + (cond + ((file-remote-p default-directory) + ;; In tramp mode and local windows, remote nix-like, + ;; the `ffip-find-executable' with windows path can't be applied. + ;; Assume remote server has already added EXE into $PATH! + ;; Thanks for ShuguangSun for the fix + (setq rlt exe)) + ((setq rlt ffip-find-executable)) + ((eq system-type 'windows-nt) + ;; in case PATH is not setup properly + (cond + (ffip-use-rust-fd + (setq rlt (concat (getenv "USERPROFILE") + "\\\\.cargo\\\\bin\\\\" + exe + ".exe")) + (unless (file-exists-p rlt) + (setq rlt exe))) + (t + (setq rlt (ffip--win-executable-find exe))))) + ((setq rlt (executable-find exe))) + (t + ;; well, `executable-find' failed + (setq rlt exe))) + rlt)) + +(defun ffip--join-patterns (patterns) + "Convert PATTERNS into cli arguments." + (cond + ((and ffip-patterns (not ffip-use-rust-fd)) + (format "\\( %s \\)" (mapconcat (lambda (pat) (format "-iwholename \"%s\"" pat)) + patterns " -or "))) + (t + ;; rust fd only supports ONE pattern (and it's regular expression) + ;; which is precious resource to waste here + ""))) + +(defun ffip--prune-patterns () + "Turn `ffip-prune-patterns' into a string that `find' can use." + ;; Both fd and find use "glob pattern" + ;; @see https://en.wikipedia.org/wiki/Glob_%28programming%29 + (cond + (ffip-use-rust-fd + ;; fd match relative path + (mapconcat (lambda (p) + (format "-E \"%s\"" (replace-regexp-in-string "^\*/" "" p))) + ffip-prune-patterns " ")) + (t + ;; find match whole path + (mapconcat (lambda (p) + (format "-iwholename \"%s\"" p)) + ffip-prune-patterns " -or ")))) + +(defun ffip--ignore-file-names () + "Turn `ffip-ignore-filenames' into a string that `find' can use." + ;; @see `ffip-prune-patterns' for fd vs find. + (cond + (ffip-use-rust-fd + (mapconcat (lambda (p) + (format "-E \"%s\"" p)) + ffip-ignore-filenames " ")) + (t + (mapconcat (lambda (n) (format "-not -name \"%s\"" n)) + ffip-ignore-filenames " ")))) + +(defun ffip--file-completion-table (all-files) + ;; direct copy of project--file-completion-table + (lambda (string pred action) + (cond + ((eq action 'metadata) + '(metadata . ((category . project-file)))) + (t + (complete-with-action action all-files string pred))))) + +;;;###autoload +(defun ffip-completing-read (prompt collection &optional action) + "Read a string in minibuffer, with completion. + +PROMPT is a string with same format parameters in `completing-read'. +COLLECTION is a list of strings. + +ACTION is a lambda function to call after selecting a result. + +This function returns the selected candidate or nil." + (let* (selected) + (cond + ((= 1 (length collection)) + ;; select the only candidate immediately + (setq selected (car collection))) + + (ffip-prefer-ido-mode + ;; ido can only handle list of strings + (setq selected (ido-completing-read prompt (mapcar 'car collection)))) + + (t + (setq selected + (completing-read prompt (ffip--file-completion-table collection))) + (setq selected (or (assoc selected collection) selected)))) + + (when selected + ;; make sure only the string/file is passed to action + (let* ((default-directory (ffip-get-project-root-directory)) + (result (if (consp selected) (cdr selected) selected))) + (if action (funcall action result) result))))) + +(defun ffip-create-shell-command (keyword find-directory-p) + "Produce command to search KEYWORD. +If FIND-DIRECTORY-P is t, we look up directory instead of file. +Rust fd use regular expression. +BSD/GNU Find use glob pattern." + (let* (cmd fmt tgt) + (cond + (ffip-use-rust-fd + ;; `-H` => search hidden files + ;; `-E` => exclude pattern + ;; `-c` => color + ;; `-i` => case insensitive + ;; `-t` => directory (d) or file (f) + ;; `-p` => match full path + (setq fmt (concat "%s %s -c never -H -i -t %s %s %s %s" + (if ffip-rust-fd-respect-ignore-files "" " -I") + (if ffip-match-path-instead-of-filename " -p" "") + " " + ffip-rust-fd-extra-opts + " %s")) + ;; fd use regular expression for target pattern (but glob pattern when excluding, sigh) + (setq tgt (if keyword (format "\".*%s\"" keyword) ""))) + (t + (setq tgt + (if find-directory-p (format "-iwholename \"*%s\"" keyword) + (ffip--create-filename-pattern-for-gnufind keyword))) + (setq fmt (concat "%s " + ffip-find-pre-path-options + " . \\( %s \\) -prune -o -type %s %s %s %s %s -print")))) + + (setq cmd (format fmt + (ffip--executable-find) + (ffip--prune-patterns) + (if find-directory-p "d" "f") + (ffip--ignore-file-names) + ffip-find-options + (ffip--join-patterns ffip-patterns) + tgt)) + cmd)) + +(defun ffip-glob-to-regex (s) + "Convert glob pattern S into regular expression." + (setq s (replace-regexp-in-string "\\." "\\\\." s)) + (setq s (replace-regexp-in-string "\*" ".*" s)) + s) + +(defmacro ffip-push-one-candidate (file result) + "Push FILE into RESULT." + ;; @see https://www.murilopereira.com/how-to-open-a-file-in-emacs/ + ;; also @see #15 improving handling of directories containing space + `(push (cons (replace-regexp-in-string "^\./" "" ,file) ,file) ,result)) + +(defun ffip-project-search-default-function (find-command) + "Execute FIND-COMMAND in shell and split its output into lines." + (if ffip-debug "ffip-project-search-default-function => find-command=%s" find-command) + (split-string (shell-command-to-string find-command) "[\r\n]+" t)) + +;;;###autoload +(defun ffip-project-search (keyword &optional find-directory-p) + "Return an alist of all filenames in the project and their path. + +Files with duplicate filenames are suffixed with the name of the +directory they are found in so that they are unique. + +If KEYWORD is string, it's the file name or file path to find file. +If KEYWORD is list, it's the list of file names. +IF FIND-DIRECTORY-P is t, we are searching directories, else files." + (let* ((default-directory (ffip-get-project-root-directory)) + (cmd (ffip-create-shell-command keyword find-directory-p)) + (collection (funcall ffip-project-search-function cmd)) + rlt) + + (if ffip-debug (message "run command at %s: %s" default-directory cmd)) + + ;; use simple loop statement for clean code + (cond + ((and ffip-use-rust-fd ffip-patterns) + (let* ((fd-file-pattern (concat "^" + (mapconcat 'ffip-glob-to-regex ffip-patterns "\\|") + "$"))) + (dolist (file collection) + ;; filter result with Lisp because fd does NOT support multiple patterns + (if (string-match fd-file-pattern file) (ffip-push-one-candidate file rlt))))) + + (t + (dolist (file collection) + (ffip-push-one-candidate file rlt)))) + + (nreverse rlt))) + +(defun ffip--forward-line (lnum) + "Forward LNUM lines." + (if ffip-debug (message "ffip--forward-line called => %s" lnum)) + (when (and lnum (> lnum 0)) + (goto-char (point-min)) + (forward-line (1- lnum)))) + +(defun ffip-hint () + "Hint." + (let ((root (ffip-get-project-root-directory))) + (format "Find in %s/: " + (file-name-nondirectory (directory-file-name root))))) + +(defun ffip-select-and-open-file (files new-window-p directory-p fn lnum) + "Select and open file from FILES. +If NEW-WINDOW-P is t, create a new window for opened file. +If DIRECTORY-P is t, open directory instead of file. +IF the function FN is not nil, call it after opening the selected file. +After opening the file, forward LNUM lines." + (ffip-completing-read + (ffip-hint) + files + `(lambda (file) + ;; only one item in project files + (if ,directory-p + (if (quote ,new-window-p) + (dired-other-window file) + (switch-to-buffer (dired file))) + ;; open file + (if (quote ,new-window-p) + (find-file-other-window file) + (find-file file)) + ;; goto line if needed + (ffip--forward-line ,lnum) + (if ,fn (funcall ,fn file)))))) + +;;;###autoload +(defun ffip-find-files (keyword open-another-window &optional find-directory-p fn) + "Use KEYWORD to find files. +If OPEN-ANOTHER-WINDOW is t, the results are displayed in a new window. +If FIND-DIRECTORY-P is t, only search directories. FN is callback. +This function is the API to find files." + (let (cands lnum) + ;; extract line num if exists + (when (and keyword (stringp keyword) + (string-match "^\\(.*\\):\\([0-9]+\\):?$" keyword)) + (setq lnum (string-to-number (match-string 2 keyword))) + (setq keyword (match-string 1 keyword))) + + (setq cands (ffip-project-search keyword find-directory-p)) + (cond + ((> (length cands) 0) + + (unless (eq ffip-find-files-history-max-items 0) + ;; save the history + (when (>= (length ffip-find-files-history) + ffip-find-files-history-max-items) + ;; kick out the oldest item + (setq ffip-find-files-history (butlast ffip-find-files-history))) + ;; add the latest item + (push (list :files cands + :keyword keyword + :directory-p find-directory-p + :function fn + :forward-lines lnum + :default-directory (ffip-get-project-root-directory)) + ffip-find-files-history)) + + (ffip-select-and-open-file cands + open-another-window + find-directory-p + fn + lnum)) + + (t + (message "Nothing found!"))))) + +;;;###autoload +(defun ffip-find-files-resume (&optional n) + "Resume the last Nth `ffip-find-file' operation. +Please note N is zero originated." + (interactive "P") + (unless n (setq n 0)) + (cond + ((>= n ffip-find-files-history-max-items) + (message "There are only %d items in `ffip-find-files-history'." + ffip-find-files-history-max-items)) + (t + (let* ((item (nth n ffip-find-files-history)) + (default-directory (plist-get item :default-directory))) + (ffip-select-and-open-file (plist-get item :files) + nil + (plist-get item :directory-p) + (plist-get item :function) + (plist-get item :forward-lines)))))) + +(defun ffip--prepare-root-data-for-project-file (root) + "Prepare data for ROOT." + (cons 'ffip-project-root root)) + +(defun ffip--read-selected () + "Read select string." + (buffer-substring-no-properties (region-beginning) (region-end))) + +(defun ffip-read-keyword () + "Read keyword from selected text or user input." + (let* ((hint (if ffip-use-rust-fd "Enter regex (or press ENTER): " + "Enter keyword (or press ENTER): ")) + rlt) + (cond + ((region-active-p) + (push (ffip--read-selected) ffip-filename-history) + (setq rlt (ffip--read-selected))) + (t + (setq rlt (read-from-minibuffer hint nil nil nil 'ffip-filename-history)))) + (if rlt (string-trim rlt) rlt))) + +;;;###autoload +(defun ffip-create-project-file () + "Create or Append .dir-locals.el to set up per directory. +You can move .dir-locals.el to root directory. +See (info \"(Emacs) Directory Variables\") for details." + (interactive) + (let* ((root (read-directory-name "Project root directory: " default-directory)) + (file (if (and root (file-exists-p root)) + (concat (file-name-as-directory root) ".dir-locals.el")))) + (when file + (with-temp-buffer + (let ((print-level nil) (print-length nil) sexp) + (cond + ;; modify existing .dir-locals.el + ((file-exists-p file) + (let (sub-sexp new-sub-sexp) + (setq sexp (ffip--read-file-text file)) + ;; valid .dir-locals.el + (when sexp + ;; the list for nil + (setq sub-sexp (assoc nil sexp)) + (cond + ;; `(nil (prop1 . val1) (prop2 . val2))' exists + (sub-sexp + ;; remove (ffip-project-root . "/path/file") + (if (assoc 'ffip-project-root sub-sexp) + (setq new-sub-sexp (delete (assoc 'ffip-project-root sub-sexp) sub-sexp)) + (setq new-sub-sexp sub-sexp)) + (push (ffip--prepare-root-data-for-project-file root) new-sub-sexp) + ;; update sexp + (setq sexp (delete sub-sexp sexp)) + (push new-sub-sexp sexp)) + (t + ;; add `(nil (ffip-project-root . "path/file"))' + (push (list nil (ffip--prepare-root-data-for-project-file root)) sexp)))) + )) + (t + ;; a new .dir-locals.el + (setq sexp (list (list nil (ffip--prepare-root-data-for-project-file root)))))) + (when sexp + (insert (format "%S" sexp)) + (write-file file) + (message "%s created." file))))))) + +;;;###autoload +(defun ffip-current-full-filename-match-pattern-p (regex) + "Is current full file name (including directory) match the REGEX?" + (let* ((dir (if (buffer-file-name) (buffer-file-name) ""))) + (string-match-p regex dir))) + +;;;###autoload +(defun find-file-in-project (&optional open-another-window) +"More powerful and efficient `find-file-in-project-by-selected' is recommended. + +Prompt with a completing list of all files in the project to find one. +If OPEN-ANOTHER-WINDOW is not nil, the file will be opened in new window. +The project's scope is defined as the first directory containing +a `ffip-project-file' whose value is \".git\" by default. +You can override this by setting the variable `ffip-project-root'." + (interactive "P") + (ffip-find-files nil open-another-window)) + +(defun ffip-file-name-relative-p (filename) + "Is FILENAME relative?" + (if (string-match-p ffip-relative-path-pattern filename) t)) + +(defun ffip-guess-file-name-at-point () + "Guess file name at point. File name could contain environment variables." + (let* ((file (or (and (region-active-p) (ffip--read-selected)) + (thing-at-point 'filename) + (thing-at-point 'symbol) + (read-string "No file name at point. Please provide one: ")))) + (when file + ;; replace environment variable in file name + (car (ff-list-replace-env-vars (list file)))))) + +(defun ffip--guess-physical-path (file) + "Return physical full path of FILE which does exist." + (let* (rlt tmp) + ;; only deal with file path + (when (or (file-name-absolute-p file) + (ffip-file-name-relative-p file)) + (cond + ;; file already exists + ((and (file-exists-p file) + ;; not directory + (not (car (file-attributes file)))) + (setq rlt (file-truename file))) + + ;; extra effort for javascript like language + ;; "./lib/A" could mean "./lib/A.js" or "./lib/A/index.js" + ((and (or (derived-mode-p 'js-mode) + (memq major-mode '(typescript-mode)))) + (dolist (ext '(".ts" ".tsx" ".js" ".jsx")) + ;; guess physical path + (cond + ;; "./lib/A.js" or "./lib/A.ts" + ((file-exists-p (setq tmp (concat file ext))) + (setq rlt (file-truename tmp))) + + ;; "./lib/A/index.js" or "./lib/A/index.ts" + ((file-exists-p (setq tmp (concat (file-name-as-directory file) "index" ext))) + (setq rlt (file-truename tmp)))))))) + + rlt)) + +;;;###autoload +(defun find-file-in-project-at-point (&optional open-another-window) + "Find file at point. File path could contain environment variables. +If OPEN-ANOTHER-WINDOW is not nil, the file will be opened in new window." + (interactive "P") + (let* ((fn (ffip-guess-file-name-at-point)) + ;; could be a path + (ffip-match-path-instead-of-filename t) + full-path) + (cond + (fn + (cond + ;; is relative/full path and path is real + ((setq full-path (ffip--guess-physical-path fn)) + (if open-another-window (find-file-other-window full-path) + (find-file full-path))) + + ;; absolute path which does not exist + ((file-name-absolute-p fn) + ;; search file name only + (let* ((ffip-match-path-instead-of-filename nil)) + (ffip-find-files (file-name-nondirectory fn) open-another-window))) + + (t + ;; strip prefix "../../" or "././" from file name + (ffip-find-files (replace-regexp-in-string ffip-relative-path-pattern "" fn) + open-another-window)))) + (t + (message "No file name is provided."))))) + +(defun ffip-parent-directory (level directory) + "Return LEVEL up parent directory of DIRECTORY." + (let* ((rlt directory)) + (while (and (> level 0) (not (string= "" rlt))) + (setq rlt (file-name-directory (directory-file-name rlt))) + (setq level (1- level))) + (if (string= "" rlt) (setq rlt nil)) + rlt)) + +;;;###autoload +(defun find-file-in-current-directory (&optional level) + "Search file in current directory or LEVEL up parent directory." + (interactive "P") + (unless level (setq level 0)) + (let* ((ffip-project-root (ffip-parent-directory level default-directory))) + (find-file-in-project nil))) + +;;;###autoload +(defun find-file-in-project-by-selected (&optional open-another-window) + "Same as `find-file-in-project' but more powerful and faster. +It use string from selected region to search files in the project. +If no region is selected, you could provide a keyword. + +Keyword could be ANY part of the file's full path and support wildcard. +For example, to find /home/john/proj1/test.js, below keywords are valid: +- test.js +- roj1/tes +- john*test + +If keyword contains line number like \"hello.txt:32\" or \"hello.txt:32:\", +we will move to that line in opened file. + +If keyword is empty, it behaves same as `find-file-in-project'. + +If OPEN-ANOTHER-WINDOW is not nil, the file will be opened in new window." + (interactive "P") + (ffip-find-files (ffip-read-keyword) open-another-window)) + +;;;###autoload +(defun ffip-insert-file () + "Insert contents of file in current buffer. +The file name is selected interactively from candidates in project." + (interactive) + (let* ((cands (ffip-project-search (ffip-read-keyword)))) + (when (> (length cands) 0) + (ffip-completing-read (ffip-hint) + cands + 'insert-file)))) + +;;;###autoload +(defun find-file-with-similar-name (&optional open-another-window) + "Use base name of current file as keyword which could be further stripped. +by `ffip-strip-file-name-regex'. +If OPEN-ANOTHER-WINDOW is not nil, the file will be opened in new window." + (interactive "P") + (when buffer-file-name + (let* ((keyword (concat (file-name-base buffer-file-name) ".*") )) + (if ffip-strip-file-name-regex + (setq keyword (replace-regexp-in-string ffip-strip-file-name-regex + "" + keyword))) + (ffip-find-files keyword open-another-window)))) + +;;;###autoload +(defun find-file-in-current-directory-by-selected (&optional open-another-window) + "Like `find-file-in-project-by-selected' but search current directory. +If OPEN-ANOTHER-WINDOW is not nil, the file will be opened in new window." + (interactive "P") + (let* ((ffip-project-root default-directory)) + (find-file-in-project-by-selected open-another-window))) + +;;;###autoload +(defun ffip-find-relative-path(&optional find-directory-p) + "Find file/directory and copy its relative path into `kill-ring'. +If FIND-DIRECTORY-P is t, copy the directory path. +Set `ffip-find-relative-path-callback' to format the result." + (interactive "P") + (let* ((cands (ffip-project-search (ffip-read-keyword) find-directory-p))) + (cond + ((> (length cands) 0) + (ffip-completing-read + (ffip-hint) + cands + `(lambda (file) + ;; only one item in project files + (if ,find-directory-p + (setq file (file-name-as-directory file))) + (setq file (file-relative-name file + (if buffer-file-name + (file-name-directory buffer-file-name) + (expand-file-name default-directory)))) + (funcall ffip-find-relative-path-callback file)))) + (t + (message "Nothing found!"))))) + +;;;###autoload +(defun find-directory-in-project-by-selected (&optional open-another-window) + "Similar to `find-file-in-project-by-selected'. +Use string from selected region to find directory in the project. +If no region is selected, you need provide keyword. + +Keyword could be directory's base-name only or parent-directory+base-name +For example, to find /home/john/proj1/test, below keywords are valid: +- test +- roj1/test +- john*test + +If OPEN-ANOTHER-WINDOW is not nil, the file will be opened in new window." + (interactive "P") + (ffip-find-files (ffip-read-keyword) open-another-window t)) + +(defun ffip--prune-patterns-regex () + "Convert `ffip--prune-patterns-regex to regex." + (let* ((rlt (mapconcat 'identity ffip-prune-patterns "\\|"))) + (setq rlt (replace-regexp-in-string "\\." "\\\\." rlt)) + (setq rlt (replace-regexp-in-string "\\*" ".*" rlt)) + ;; file name or directory name + (concat rlt "\\($\\|/\\)" ))) + +;;;###autoload +(defun ffip-lisp-find-file-in-project (&optional directory-p) + "If DIRECTORY-P is nil, find file in project, or else find directory. +This command works in any environment (Windows, etc) out of box." + (interactive "P") + (let* ((root (ffip-get-project-root-directory)) + (input-regex (read-string "Input regex (or press ENTER): ")) + (find-lisp-regexp (if (string= input-regex "") ".*" input-regex)) + cands + (ignored-regex (ffip--prune-patterns-regex))) + (cond + (directory-p + (setq cands (find-lisp-find-files-internal + root + 'find-lisp-file-predicate-is-directory + 'find-lisp-default-directory-predicate))) + (t + (setq cands (find-lisp-find-files-internal + root + 'find-lisp-default-file-predicate + 'find-lisp-default-directory-predicate)))) + (setq cands + (delq nil + (mapcar `(lambda (c) + (unless (string-match ,ignored-regex c) c)) + cands))) + (ffip-completing-read + (format "%s %s: " (if directory-p "directories" "files") root) + cands + `(lambda (file) + (if ,directory-p + (switch-to-buffer (dired file)) + (find-file file)))))) + +;;;###autoload +(defalias 'ffip 'find-file-in-project) +;;;###autoload +(defalias 'find-relative-path 'ffip-find-relative-path) + +(defun ffip-path (candidate) + "Get path from CANDIDATE." + (let* ((default-directory (ffip-project-root))) + (file-truename (if (consp candidate) (cdr candidate) candidate)))) + +;;;###autoload +(defun ffip-diff-quit () + "Quit." + (interactive) + ;; kill buffer instead of bury it + (quit-window t)) + +;;;###autoload +(defun ffip-diff-find-file (&optional open-another-window) + "File file(s) in current hunk. +If OPEN-ANOTHER-WINDOW is not nil, the file will be opened in new window." + (interactive "P") + (let* ((files (mapcar (lambda (f) (replace-regexp-in-string "^[^/]*/" "" f)) (diff-hunk-file-names))) + (alnum 0) + (blnum 0) + (regex "\\(?:\\*\\{15\\}.*\n\\)?[-@* ]*\\([0-9,]+\\)\\([ acd+]+\\([0-9,]+\\)\\)?") + (ffip-match-path-instead-of-filename (not ffip-diff-find-file-by-file-name-p)) + keyword) + + (save-excursion + (diff-beginning-of-hunk t) + (when (looking-at regex) + (setq alnum (string-to-number (match-string 1))) + (setq blnum (string-to-number (match-string 3))))) + + (cond + ((or (null files) (eq (length files) 0)) + (message "No file is found!")) + + ;; file A and file B have the same name + ((or (and (> (length files) 1) + (string= (nth 0 files) (nth 1 files))) + (eq (length files) 1)) + (setq keyword (nth 0 files)) + (when ffip-diff-find-file-by-file-name-p + (setq keyword (file-name-nondirectory keyword))) + + (ffip-find-files keyword + open-another-window + nil + `(lambda (opened-file) + ;; use line number in new file since there + ;; is only one file name candidate + (ffip--forward-line ,blnum)))) + + (t + (unless (setq keyword (run-hook-with-args 'ffip-diff-find-file-before-hook + (nth 0 files) + (nth 1 files))) + ;; pick a file name from A and B + (setq keyword (cond + ((string= (nth 0 files) "null") + (nth 1 files)) + (t + (nth 0 files))))) + (when ffip-diff-find-file-by-file-name-p + (setq keyword (file-name-nondirectory keyword))) + + (ffip-find-files keyword + open-another-window + nil + (lambda (opened-file) + (cond + ((string= (file-name-nondirectory opened-file) (nth 0 files)) + (ffip--forward-line alnum)) + (t + (ffip--forward-line blnum))))))))) + +(defvar ffip-diff-mode-map + (let ((map (make-sparse-keymap))) + (set-keymap-parent map diff-mode-map) + (define-key map (kbd "C-c C-k") 'ffip-diff-filter-hunks-by-file-name) + (define-key map [remap diff-goto-source] 'ffip-diff-find-file) + map) + "Mode map based on `diff-mode-map'.") + +;;;###autoload +(define-derived-mode ffip-diff-mode diff-mode "ffip" + "Show diff/patch." + (setq buffer-read-only t) + (setq truncate-lines t) + (use-local-map ffip-diff-mode-map)) + +(defun ffip-show-content-in-diff-mode (content) + "Insert CONTENT into *ffip-diff* buffer." + (cond + ((and content (not (string= content ""))) + (let (rlt-buf) + (if (get-buffer "*ffip-diff*") + (kill-buffer "*ffip-diff*")) + (setq rlt-buf (get-buffer-create "*ffip-diff*")) + (save-current-buffer + (switch-to-buffer-other-window rlt-buf) + (set-buffer rlt-buf) + (erase-buffer) + (insert content) + (ffip-diff-mode) + (goto-char (point-min))))) + (t + (message "Output is empty!")))) + +(defun ffip-diff-execute-backend (backend) + "Execute BACKEND." + (if backend + (cond + ;; shell command + ((stringp backend) + (ffip-show-content-in-diff-mode (shell-command-to-string backend))) + ;; command + ((functionp backend) + (ffip-show-content-in-diff-mode (funcall backend))) + ;; lisp expression + ((consp backend) + (ffip-show-content-in-diff-mode (funcall `(lambda () ,backend))))))) + +(defun ffip-backend-description (backend) + "Get BACKEND description." + (let* (rlt) + (cond + ;; shell command + ((stringp backend) + (setq rlt backend)) + ;; command + ((functionp backend) + (setq rlt (symbol-name backend))) + ;; lisp expression + ((consp backend) + ;; (cons "description" actual-backend) + (if (stringp (car backend)) + (setq rlt (car backend)) + (setq rlt "unknown")))) + rlt)) + +;;;###autoload +(defun ffip-show-diff-internal (&optional num) + "Show the diff output by executing selected `ffip-diff-backends'. +NUM is the index selected backend from `ffip-diff-backends'. +NUM is zero based whose default value is zero." + (interactive "P") + (cond + ((or (not num) (< num 0)) + (setq num 0)) + ((> num (length ffip-diff-backends)) + (setq num (1- (length ffip-diff-backends))))) + + (let* ((backend (nth num ffip-diff-backends))) + (if (and (consp backend) + (stringp (car backend))) + (setq backend (cdr backend))) + (ffip-diff-execute-backend backend))) + +;;;###autoload +(defun ffip-show-diff-by-description (&optional num) + "Show the diff output by executing selected `ffip-diff-backends'. +NUM is the backend index of `ffip-diff-backends'. +If NUM is not nil, the corresponding backend is executed directly." + (interactive "P") + (cond + (num + (ffip-show-diff-internal num)) + (t + (let* (descriptions + (i 0)) + ;; format backend descriptions + (dolist (b ffip-diff-backends) + (push (format "%s: %s" i (ffip-backend-description b)) descriptions) + (setq i (+ 1 i))) + (ffip-completing-read + "Run diff backend: " + (nreverse descriptions) + (lambda (file) + (if (string-match "^\\([0-9]+\\): " file) + (ffip-show-diff-internal (string-to-number (match-string 1 file)))))))))) + +;;;###autoload +(defalias 'ffip-show-diff 'ffip-show-diff-by-description) + +(defun ffip-read-file-name-hack (orig-func &rest args) + "Advice `read-file-name' with ORIG-FUNC and ARGS for `ffip-diff-apply-hunk'." + (cond + (ffip-read-file-name-hijacked-p + ;; only hack read-file-name once + (setq ffip-read-file-name-hijacked-p nil) + (let* ((file-name (file-name-nondirectory (nth 2 args))) + (default-directory (ffip-project-root)) + (cands (ffip-project-search file-name)) + (rlt (if cands (ffip-completing-read "Files: " cands)))) + (message "file-name=%s" file-name) + (when rlt + (setq rlt (file-truename rlt)) + (run-hook-with-args 'ffip-diff-apply-hunk-hook rlt) + rlt))) + (t + (apply orig-func args)))) +(advice-add 'read-file-name :around #'ffip-read-file-name-hack) + +;;;###autoload +(defun ffip-diff-apply-hunk (&optional reverse) + "Apply current hunk in `diff-mode'. Try to locate the file to patch. +Similar to `diff-apply-hunk' but smarter. +Please read documentation of `diff-apply-hunk' to get more details. +If REVERSE is t, applied patch is reverted." + (interactive "P") + (cond + ((derived-mode-p 'diff-mode) + (setq ffip-read-file-name-hijacked-p t) + (diff-apply-hunk reverse) + (setq ffip-read-file-name-hijacked-p nil)) + (t + (message "This command only run in `diff-mode' and `ffip-diff-mode'.")))) + +(defun ffip-diff-hunk-file-name-match-p (keyword neg-keywords) + "Current hunk's file name does match KEYWORD and doesn't NEG-KEYWORDS." + (let* ((filenames (diff-hunk-file-names)) + (f0 (nth 0 filenames)) + (f1 (nth 1 filenames)) + rlt) + (when (and filenames (> (length filenames) 1)) + (setq rlt (or (string-match keyword f0) (string-match keyword f1))) + + (let ((i 0) nk) + (while (and rlt (< i (length neg-keywords))) + (setq nk (nth i neg-keywords)) + (setq rlt (not (or (string-match nk f0) (string-match nk f1)))) + (setq i (1+ i))))) + rlt)) + +;;;###autoload +(defun ffip-diff-filter-hunks-by-file-name () + "Filter hunks by file names which are generated from user input patterns. +E.g., \"regex !exclude1 exclude1\" means the hunk's file name should +match \"regex\", but should not match \"exclude1\" or \"exclude2\". +Please note in \"regex\", space represents any string." + (interactive) + (cond + ((derived-mode-p 'diff-mode) + (let* ((pattern (read-string "File pattern (e.g., \"regex !exclude1 exclude2\"): ")) + arr + keyword + neg-keywords + (first-hunk-position (save-excursion + (goto-char (point-min)) + (re-search-forward diff-hunk-header-re) + (line-end-position)))) + (cond + ((and pattern (not (string= pattern ""))) + (setq arr (split-string pattern "!")) + (setq keyword (string-trim (nth 0 arr))) + (when (> (length arr) 1) + (setq neg-keywords (split-string (string-trim (nth 1 arr)) " +"))) + + ;; kill from the bottom to the top + (goto-char (point-max)) + (condition-case nil + (while (not (and (<= (point) first-hunk-position) + (ffip-diff-hunk-file-name-match-p keyword neg-keywords))) + (cond + ((not (ffip-diff-hunk-file-name-match-p keyword neg-keywords)) + (diff-file-kill)) + (t + (diff-file-prev)))) + (error nil))) + (t + (message "File kill pattern should not be empty"))))) + (t + (message "This command only run in `diff-mode' and `ffip-diff-mode'.")))) + +;;;###autoload +(defun ffip-fix-file-path-at-point (&optional absolute-path-p) + "Fix file path at point. File path could contain environment variables. +If ABSOLUTE-PATH-P is t, old path is replaced by correct absolute path. +Or else it's replaced by relative path." + (interactive "P") + (let* ((filename (ffip-guess-file-name-at-point)) + full-path + cands) + (cond + ((not filename) + (message "There is no file path at point.")) + + ;; path at point is a path of physical file + ((setq full-path (ffip--guess-physical-path filename)) + nil) + + ;; find a file + ((setq cands + (ffip-project-search (replace-regexp-in-string ffip-relative-path-pattern + "" + filename))) + (cond + ((eq (length cands) 1) + (setq full-path (nth 0 cands))) + (t + (setq full-path (completing-read "Find file: " cands)))))) + + (when full-path + (if (consp full-path) (setq full-path (cdr full-path))) + + ;; convert to actual full path + (let* ((default-directory (ffip-get-project-root-directory))) + (setq full-path (file-truename full-path))) + + (let* ((bounds (bounds-of-thing-at-point 'filename)) + (path (if absolute-path-p full-path + (file-relative-name full-path + ;; compare with current file's directory if possible + (and buffer-file-name (file-name-directory buffer-file-name)))))) + (goto-char (car bounds)) + (delete-region (car bounds) (cdr bounds)) + (insert (replace-regexp-in-string ffip-fix-file-path-at-point-strip-regex "" path)))))) + +;; safe locals +(progn + (put 'ffip-diff-backends 'safe-local-variable 'listp) + (put 'ffip-patterns 'safe-local-variable 'listp) + (put 'ffip-prune-patterns 'safe-local-variable 'listp) + (put 'ffip-ignore-filenames 'safe-local-variable 'listp) + (put 'ffip-match-path-instead-of-filename 'safe-local-variable 'booleanp) + (put 'ffip-project-file 'safe-local-variable 'stringp) + (put 'ffip-strip-file-name-regex 'safe-local-variable 'stringp) + (put 'ffip-project-root 'safe-local-variable 'stringp)) + +(provide 'find-file-in-project) +;;; find-file-in-project.el ends here |