diff options
Diffstat (limited to '.config/emacs/lisp/dumb-jump.el')
| -rw-r--r-- | .config/emacs/lisp/dumb-jump.el | 5706 |
1 files changed, 0 insertions, 5706 deletions
diff --git a/.config/emacs/lisp/dumb-jump.el b/.config/emacs/lisp/dumb-jump.el deleted file mode 100644 index 39e1f63..0000000 --- a/.config/emacs/lisp/dumb-jump.el +++ /dev/null @@ -1,5706 +0,0 @@ -;;; dumb-jump.el --- Jump to definition for 60+ languages without configuration -*- lexical-binding: t; -*- -;; Copyright (C) 2015-2026 jack angers -;; Author: jack angers and contributors -;; Url: https://github.com/jacktasia/dumb-jump -;; Version: 0.5.5 -;; Package-Requires: ((emacs "26.1")) -;; Keywords: programming - -;; Dumb Jump 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. -;; -;; Dumb Jump 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 Dumb Jump. If not, see http://www.gnu.org/licenses. - -;;; Commentary: - -;; Dumb Jump is an Emacs "jump to definition" package with support for 60+ programming languages that favors -;; "just working" over speed or accuracy. This means minimal -- and ideally zero -- configuration with absolutely -;; no stored indexes (TAGS) or persistent background processes. -;; -;; Dumb Jump provides a xref-based interface for jumping to -;; definitions. It is based on tools such as grep, the silver searcher -;; (https://geoff.greer.fm/ag/), ripgrep -;; (https://github.com/BurntSushi/ripgrep) or git-grep -;; (https://git-scm.com/docs/git-grep). -;; -;; To enable Dumb Jump, add the following to your initialisation file: -;; -;; (add-hook 'xref-backend-functions #'dumb-jump-xref-activate) -;; -;; Now pressing M-. on an identifier should open a buffer at the place -;; where it is defined, or a list of candidates if uncertain. This -;; list can be navigated using M-g M-n (next-error) and M-g M-p -;; (previous-error). -;;; Code: -(require 'xref) -(require 'cl-generic) -(require 'cl-lib) -(require 'seq) -(require 'subr-x) -(require 'json) -(require 'project nil 'noerror) - -(defun dumb-jump--chop-prefix (prefix text) - "Remove PREFIX from TEXT when present." - (if (and (stringp prefix) - (stringp text) - (string-prefix-p prefix text)) - (substring text (length prefix)) - text)) - -(defun dumb-jump--contains-p (needle text &optional ignore-case) - "Return non-nil when TEXT contains NEEDLE as a literal substring. -When IGNORE-CASE is non-nil, match without case sensitivity." - (and (stringp needle) - (stringp text) - (save-match-data - (let ((case-fold-search ignore-case)) - (if (string-match-p (regexp-quote needle) text) t nil))))) - -(defun dumb-jump--index-of (needle text) - "Return the index of NEEDLE in TEXT, or nil when not found." - (when (and (stringp needle) (stringp text)) - (save-match-data - (string-match-p (regexp-quote needle) text)))) - -(defun dumb-jump--join (separator strings) - "Join STRINGS using SEPARATOR." - (mapconcat #'identity strings separator)) - -(defun dumb-jump--match (regexp text &optional start) - "Return list of REGEXP matches in TEXT from START, or nil." - (when (and (stringp regexp) - (stringp text)) - (save-match-data - (when (string-match regexp text start) - (let* ((group-count (/ (length (match-data t)) 2)) - (i 0) - matches) - (while (< i group-count) - (push (match-string i text) matches) - (setq i (1+ i))) - (nreverse matches)))))) - -(defun dumb-jump--matched-positions-all (regexp text &optional start) - "Return a list of match ranges for REGEXP in TEXT from START. -Each element is a cons cell of the form (START . END)." - (when (and (stringp regexp) (stringp text)) - (save-match-data - (let ((pos (or start 0)) - matches) - (while (string-match regexp text pos) - (let ((beg (match-beginning 0)) - (end (match-end 0))) - (push (cons beg end) matches) - ;; Avoid infinite loops if REGEXP can match empty strings. - (setq pos (if (= beg end) (1+ end) end)))) - (nreverse matches))))) - -(defun dumb-jump--replace (old new text) - "Replace all OLD literal matches in TEXT with NEW." - (replace-regexp-in-string (regexp-quote old) (or new "") (or text "") t t)) - -(defun dumb-jump--split (regexp text &optional omit-nulls) - "Split TEXT on REGEXP and optionally OMIT-NULLS." - (split-string (or text "") regexp omit-nulls)) - -(defun dumb-jump--trim (text) - "Trim leading and trailing whitespace from TEXT." - (string-trim (or text ""))) - -(defun dumb-jump--select-choice (choices &optional prompt) - "Choose one of CHOICES with `completing-read'. -PROMPT defaults to \"Jump to: \"." - (completing-read (or prompt "Jump to: ") choices nil t)) - -(defun dumb-jump--show-preview (text) - "Display TEXT preview to the user." - (message "%s" text)) - -(defun dumb-jump--find-index (pred list) - "Return index of first element in LIST satisfying PRED, or nil." - (let ((i 0)) - (catch 'found - (dolist (elem list) - (when (funcall pred elem) - (throw 'found i)) - (setq i (1+ i))) - nil))) - -(defun dumb-jump--zip-pair (list1 list2) - "Return list of cons pairs from LIST1 and LIST2." - (cl-mapcar #'cons list1 list2)) - -(defun dumb-jump--splice (pred rep list) - "Replace elements in LIST matching PRED with result of calling REP on them. -REP can return a list to splice in multiple elements." - (apply #'append - (mapcar (lambda (it) - (if (funcall pred it) - (funcall rep it) - (list it))) - list))) - -(defgroup dumb-jump nil - "Easily jump to project function and variable definitions." - :group 'tools - :group 'convenience) - -;;;###autoload -(defvar dumb-jump-mode-map - (let ((map (make-sparse-keymap))) - (define-key map (kbd "C-M-g") 'dumb-jump-go) - (define-key map (kbd "C-M-p") 'dumb-jump-back) - (define-key map (kbd "C-M-q") 'dumb-jump-quick-look) - map)) - -(defvar dumb-jump--search-mode 'definitions - "Current search mode: `definitions' (default) or `references'.") - -(defcustom dumb-jump-window - 'current - "Which window to use when jumping. -Valid options are \\='current (default) or \\='other." - :group 'dumb-jump - :type '(choice (const :tag "Current window" current) - (const :tag "Other window" other))) - -(defcustom dumb-jump-use-visible-window - t - "If true will jump in a visible window that shows the opened file." - :group 'dumb-jump - :type 'boolean) - -(defcustom dumb-jump-selector - 'completing-read - "Which selector to use when there is multiple choices. -The available selectors are: -- helm : https://emacs-helm.github.io/helm/ -- ivy : https://github.com/abo-abo/swiper -- Completing Read: Emacs default `completing-read'. - -When selecting helm or ivy, if the corresponding package is not installed, -the selector falls back to `completing-read'." - :group 'dumb-jump - :type '(choice (const :tag "Helm" helm) - (const :tag "Ivy" ivy) - (const :tag "Completing Read" completing-read))) - -(defcustom dumb-jump-ivy-jump-to-selected-function - #'dumb-jump-ivy-jump-to-selected - "Prompts user for a choice using ivy then dumb-jump to that choice." - :group 'dumb-jump - :type 'function) - -(defcustom dumb-jump-prefer-searcher nil - "The preferred searcher command line tool to use. -The available choices are: -- \\='ag : https://github.com/ggreer/the_silver_searcher -- \\='rg : https://github.com/BurntSushi/ripgrep -- \\='grep : https://en.wikipedia.org/wiki/Grep -- \\='gnu-grep : https://www.gnu.org/software/grep/manual/grep.html -- \\='git-grep : https://git-scm.com/docs/git-grep -- \\='git-grep-plus-ag - -If nil, select the most optimal searcher at runtime, looking for all -tools listed above except for git-grep in the order of that list. -However, the choice is overridden by `dumb-jump-force-searcher' selection -unless that is nil." - :group 'dumb-jump - :type '(choice (const :tag "Best Available" nil) - (const :tag "ag" ag) - (const :tag "rg" rg) - (const :tag "grep" grep) - (const :tag "gnu-grep" gnu-grep) - (const :tag "git grep" git-grep) - (const :tag "git grep + ag" git-grep-plus-ag))) - -(defcustom dumb-jump-force-searcher nil - "Search tool override of `dumb-jump-prefer-searcher' selection. - -By default this is nil to honour the choice made by `dumb-jump-prefer-searcher'. - -However, you may want to override that choice for some projects by identifying -one of two preferred choice overriding methods: -- Override preferred via user-specified function: - Enter the name of a function that takes the current directory and return the - search tool symbol to use for this project or nil if the choice made in - `dumb-jump-prefer-searcher' must be honoured. -- Override preferred for directories needing git-grep: - Specify one or more project directories where the git-grep search tool must - be used. -- Override to a specific tool. That is mostly useful to set the overriding - inside the .dir-locals.el of the directory. - The choices are: \\='ag, \\='rg, \\='grep, \\='gnu-grep, \\='git-grep, or - \\='git-grep-plus-ag." - :group 'dumb-jump - :type '(choice (const - :tag "nil: honour `dumb-jump-prefer-searcher' choice." nil) - (function - :tag "Override preferred via user-specified function") - (repeat - :tag "Override preferred for directories needing git-grep" - (directory :tag "Repo root")) - (const :tag "ag" ag) - (const :tag "rg" rg) - (const :tag "grep" grep) - (const :tag "gnu grep" gnu-grep) - (const :tag "git grep" git-grep) - (const :tag "git grep + ag" git-grep-plus-ag))) - -(defcustom dumb-jump-grep-prefix - "LANG=C" - "Prefix to grep command. Seemingly makes it faster for pure text." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-grep-cmd - "grep" - "The path to grep. By default assumes it is in path." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-ag-cmd - "ag" - "The path to the silver searcher. By default assumes it is in path." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-rg-cmd - "rg" - "The path to ripgrep. By default assumes it is in path." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-git-grep-cmd - "git grep" - "The path to git grep. By default assumes it is in path." - :group 'dumb-jump - :type 'string) - -;; --------------------------------------------------------------------------- -;; Dumb Jump Regular Expressions (see `dumb-jump-find-rules' docstring) - -(defcustom dumb-jump-force-using-space-bracket-exp - (eq system-type 'windows-nt) - "When t the `\\\\s` in regexp code strings is replaced by `[[:space:]]`. -Otherwise it is left in the regular expression. -Defaults to t under Windows because older gnu grep versions have problem -dealing with `\\\\s` to match end of words due to the 2 bytes used to -identify the end of line." - :group 'dumb-jump - :type 'boolean) - -(defun dumb-jump-use-space-bracket-exp-for (variant) - "Return t when `\\\\s` must be replaced by `[[:space]]` for VARIANT. -VARIANT must be a one of the following symbols: ag, rg, grep, gnu-grep, -git-grep or git-grep-plus-ag." - (and dumb-jump-force-using-space-bracket-exp - (memq variant '(grep gnu-grep git-grep git-grep-plus-ag)))) - -;; word-boundary regexps: they replace the "\\j" in dumb-jump regexes. -;; [:todo 2026-01-29, by Pierre Rouleau: Should we not exclude '_' from word boundary?] -(defcustom dumb-jump-ag-word-boundary - "(?![a-zA-Z0-9\\?\\*-])" - "Regexp that replaces `\\j` in dumb-jump regexes for ag search. -`\\b` thinks `-` is a word boundary. -When this matters use `\\j` instead and ag will use this value." - :group 'dumb-jump - :type 'string) - -;; [:todo 2026-01-29, by Pierre Rouleau: Should we not exclude '_' from word boundary?] -(defcustom dumb-jump-rg-word-boundary - "($|[^a-zA-Z0-9\\?\\*-])" - "Regexp that replaces `\\j` in dumb-jump regexes for rg search. -`\\b` thinks `-` is a word boundary. -When this matters use `\\j` instead and rg will use this value." - :group 'dumb-jump - :type 'string) - -;; [:todo 2026-01-29, by Pierre Rouleau: Should we not exclude '_' from word boundary?] -(defcustom dumb-jump-git-grep-word-boundary - "($|[^a-zA-Z0-9\\?\\*-])" - "Regexp that replaces `\\j` in dumb-jump regexes for git-grep search. -`\\b` thinks `-` is a word boundary. -When this matters use `\\j` instead and git grep will use this value." - :group 'dumb-jump - :type 'string) - -;; [:todo 2026-01-29, by Pierre Rouleau: Should we not exclude '_' from word boundary?] -(defcustom dumb-jump-grep-word-boundary - "($|[^a-zA-Z0-9\\?\\*-])" - "Regexp that replaces `\\j` in dumb-jump regexes for grep search. -`\\b` thinks `-` is a word boundary. -When this matters use `\\j` instead and grep will use this value." - :group 'dumb-jump - :type 'string) - -;; [:todo 2026-01-29, by Pierre Rouleau: Should we not exclude '_' from word boundary?] -(defcustom dumb-jump-gnu-grep-word-boundary - "($|[^a-zA-Z0-9\\?\\*-])" - "Regexp that replaces `\\j` in dumb-jump regexes for gnu grep search. -`\\b` thinks `-` is a word boundary. -When this matters use `\\j` instead and grep will use this value." - :group 'dumb-jump - :type 'string) - -;; -- - -(defcustom dumb-jump-fallback-regex - "\\bJJJ\\j" - "When `dumb-jump-fallback-search' is t use this regex. -Defaults to boundary search of symbol under point." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-fallback-search - t - "If nothing is found with normal search fallback searching fallback regex." - :group 'dumb-jump - :type 'boolean) - -(defcustom dumb-jump-zgrep-cmd - "zgrep" - "The path to grep to use for gzipped files. -By default assumes it is in path." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-grep-args "-REn" - "Grep command args [R]ecursive, [E]xtended regexes, and show line [n]umbers." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-gnu-grep-args "-rEn" - "Grep command args [r]ecursive and [E]xtended regexes, and show line [n]umbers." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-max-find-time - 2 - "Number of seconds a grep/find command can take before issuing a warning. -The warning recommend using a faster search tool and config." - :group 'dumb-jump - :type 'integer) - -(defcustom dumb-jump-functions-only - nil - "Should we only jump to functions?" - :group 'dumb-jump - :type 'boolean) - -(defcustom dumb-jump-quiet - nil - "If non-nil Dumb Jump will not log anything to *Messages*. -Note that it prevents printing when `dumb-jump-debug' is non-nil." - :group 'dumb-jump - :type 'boolean) - -(defcustom dumb-jump-ignore-context - nil - "If non-nil Dumb Jump will ignore the context of point when jumping." - :group 'dumb-jump - :type 'boolean) - -(defcustom dumb-jump-git-grep-search-untracked - t - "If non-nil Dumb Jump will also search untracked files when using git-grep." - :group 'dumb-jump - :type 'boolean) - -(defcustom dumb-jump-git-grep-search-args - "" - "Appends the passed arguments to the git-grep search function. -Default: \"\"." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-ag-search-args - "" - "Appends the passed arguments to the ag search function. -Default: \"\"." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-rg-search-args - "--pcre2" - "Appends the passed arguments to the rg search function. -Default: \"--pcre2\"." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-search-type-org-only-org - t - "If non nil restrict type ag/rg to org file. -If nil add also the language type of current src block." - :group 'dumb-jump - :type 'boolean) - -;; [:todo 2026-01-29, by Pierre Rouleau: Why 3 backslashes in front of '('? ] -(defcustom dumb-jump-find-rules - ;;-- elisp - '((:language "elisp" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\((defun|cl-defun|cl-defgeneric|cl-defmethod|cl-defsubst)\\s+JJJ\\j" - :tests ("(defun test (blah)" - "(defun test\n" - "(cl-defun test (blah)" - "(cl-defun test\n") - :not ("(defun test-asdf (blah)" - "(defun test-blah\n" - "(cl-defun test-asdf (blah)" - "(cl-defun test-blah\n" - "(defun tester (blah)" - "(defun test? (blah)" - "(defun test- (blah)")) - - (:language "elisp" :type "function" ; macros - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\((defmacro|cl-defmacro|cl-define-compiler-macro)\\s+JJJ\\j" - :tests ("(defmacro test (blah)" - "(defmacro test\n") - :not ("(defmacro test-asdf (blah)" - "(defmacro test-blah\n" - "(defmacro tester (blah)" - "(defmacro test? (blah)" - "(defmacro test- (blah)")) - - (:language "elisp" :type "function" ; hydras - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(defhydra\\b\\s*JJJ\\j" - :tests ("(defhydra test " - "(defhydra test\n" - "(defhydra test (blah\n" - "(defhydra test (blah)") - :not ("(defhydra tester" - "(defhydra test?" - "(defhydra test-" - "(defhydra test? (blah\n" - "(defhydra test? (blah)")) - - (:language "elisp" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(defvar(-local)?\\b\\s*JJJ\\j" - :tests ("(defvar test " - "(defvar test\n" - "(defvar-local test" - "(defvar-local test\n") - :not ("(defvar tester" - "(defvar test?" - "(defvar test-" - "(defvar-local tester" - "(defvar-local test?" - "(defvar-local test-")) - - (:language "elisp" :type "variable" - :supports ("ag" "grep" "rg" "ugrep" "git-grep") - :regex "\\(defconst\\b\\s*JJJ\\j" - :tests ("(defconst test " - "(defconst test\n") - :not ("(defconst tester" - "(defconst test?" - "(defconst test-")) - - (:language "elisp" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(defcustom\\b\\s*JJJ\\j" - :tests ("(defcustom test " - "(defcustom test\n") - :not ("(defcustom tester" - "(defcustom test?" - "(defcustom test-")) - - (:language "elisp" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(setq\\b\\s*JJJ\\j" - :tests ("(setq test 123)") - :not ("setq test-blah 123)" - "(setq tester" - "(setq test?" "(setq test-")) - - (:language "elisp" :type "variable" ; let bound variables - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(JJJ\\s+" - :skip-ref-filter t - :tests ("(let ((test 123)))" - "(let* ((test 123)))") - :not ("(let ((test-2 123)))" - "(let* ((test-2 123)))")) - - (:language "elisp" :type "type" ; cl-lib structured type definitions - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\((cl-defstruct|cl-deftype)\\s+JJJ\\j" - :tests ("(cl-defstruct test " - "(cl-defstruct test\n" - "(cl-deftype test " - "(cl-deftype test\n") - :not ("(cl-defstruct test-asdf (blah)" - "(cl-defstruct test-blah\n" - "(cl-deftype test-asdf (blah)" - "(cl-deftype test-blah\n")) - - (:language "elisp" :type "variable" ;; variable in method signature - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\((defun|cl-defun|cl-defgeneric|cl-defmethod)\\s*.+\\(?\\s*JJJ\\j\\s*\\)?" - :tests ("(defun blah (test)" - "(defun blah (test blah)" - "(defun (blah test)") - :not ("(defun blah (test-1)" - "(defun blah (test-2 blah)" - "(defun (blah test-3)")) - - ;;-- common lisp - (:language "commonlisp" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(def(un|macro|generic|method|setf)\\s+JJJ\\j" - ;; \\j usage see `dumb-jump-ag-word-boundary` - :tests ("(defun test (blah)" - "(defun test\n" - "(defmacro test (blah)" - "(defmacro test\n" - "(defgeneric test (blah)" - "(defgeneric test\n" - "(defmethod test (blah)" - "(defmethod test\n" - "(defsetf test (blah)" - "(defsetf test\n") - :not ("(defun test-asdf (blah)" - "(defun test-blah\n" - "(defun tester (blah)" - "(defun test? (blah)" - "(defun test- (blah)" - "(defmacro test-asdf (blah)" - "(defmacro test-blah\n" - "(defmacro tester (blah)" - "(defmacro test? (blah)" - "(defmacro test- (blah)" - "(defgeneric test-asdf (blah)" - "(defgeneric test-blah\n" - "(defgeneric tester (blah)" - "(defgeneric test? (blah)" - "(defun test- (blah)" - "(defmethod test-asdf (blah)" - "(defmethod test-blah\n" - "(defmethod tester (blah)" - "(defmethod test? (blah)" - "(defun test- (blah)" - "(defsetf test-asdf (blah)" - "(defsetf test-blah\n" - "(defsetf tester (blah)" - "(defsetf test? (blah)" - "(defun test- (blah)")) - - (:language "commonlisp" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define-(modify-macro|compiler-macro|setf-expander)\\s+JJJ\\j" - ;; \\j usage see `dumb-jump-ag-word-boundary` - :tests ("(define-modify-macro test (blah)" - "(define-modify-macro test\n" - "(define-compiler-macro test (blah)" - "(define-compiler-macro test\n") - :not ("(define-modify-macro test-asdf (blah)" - "(define-modify-macro test-blah\n" - "(define-modify-macro tester (blah)" - "(define-modify-macro test? (blah)" - "(define-modify-macro test- (blah)" - "(define-compiler-macro test-asdf (blah)" - "(define-compiler-macro test-blah\n" - "(define-compiler-macro tester (blah)" - "(define-compiler-macro test? (blah)" - "(define-compiler-macro test- (blah)")) - - (:language "commonlisp" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(def(var|parameter|constant)\\b\\s*JJJ\\j" - :tests ("(defvar test " - "(defvar test\n" - "(defparameter test " - "(defparameter test\n" - "(defconstant test " - "(defconstant test\n") - :not ("(defvar tester" - "(defvar test?" - "(defvar test-" - "(defparameter tester" - "(defparameter test?" - "(defparameter test-" - "(defconstant tester" - "(defconstant test?" - "(defconstant test-")) - - (:language "commonlisp" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define-symbol-macro\\b\\s*JJJ\\j" - :tests ("(define-symbol-macro test " - "(define-symbol-macro test\n") - :not ("(define-symbol-macro tester" - "(define-symbol-macro test?" - "(define-symbol-macro test-")) - - (:language "commonlisp" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(def(class|struct|type)\\b\\s*JJJ\\j" - :tests ("(defclass test " - "(defclass test\n" - "(defstruct test " - "(defstruct test\n" - "(deftype test " - "(deftype test\n") - :not ("(defclass tester" - "(defclass test?" - "(defclass test-" - "(defstruct tester" - "(defstruct test?" - "(defstruct test-" - "(deftype tester" - "(deftype test?" - "(deftype test-")) - - (:language "commonlisp" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define-condition\\b\\s*JJJ\\j" - :tests ("(define-condition test " - "(define-condition test\n") - :not ("(define-condition tester" - "(define-condition test?" - "(define-condition test-")) - - ;;-- racket - (:language "racket" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define\\s+\\(\\s*JJJ\\j" - :tests ("(define (test blah)" - "(define (test\n") - :not ("(define test blah" - "(define (test-asdf blah)" - "(define test (lambda (blah")) - - (:language "racket" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define\\s+JJJ\\s*\\\(\\s*lambda" - :tests ("(define test (lambda (blah" - "(define test (lambda\n") - :not ("(define test blah" - "(define test-asdf (lambda (blah)" - "(define (test)" - "(define (test blah) (lambda (foo")) - - (:language "racket" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(let\\s+JJJ\\s*(\\\(|\\\[)*" - :tests ("(let test ((blah foo) (bar bas))" - "(let test\n" - "(let test [(foo") - :not ("(let ((test blah")) - - (:language "racket" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define\\s+JJJ\\j" - :tests ("(define test " "(define test\n") - :not ("(define (test")) - - (:language "racket" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(\\\(|\\\[)\\s*JJJ\\s+" - :tests ("(let ((test 'foo" - "(let [(test 'foo" - "(let [(test 'foo" - "(let [[test 'foo" - "(let ((blah 'foo) (test 'bar)") - :not ("{test foo")) - - (:language "racket" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(lambda\\s+\\\(?[^\(\)]*\\s*JJJ\\j\\s*\\\)?" - :tests ("(lambda (test)" - "(lambda (foo test)" - "(lambda test (foo)") - :not ("(lambda () test")) - - (:language "racket" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define\\s+\\\([^\(\)]+\\s*JJJ\\j\\s*\\\)?" - :tests ("(define (foo test)" - "(define (foo test bar)") - :not ("(define foo test" - "(define (test foo" - "(define (test)")) - - (:language "racket" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(struct\\s+JJJ\\j" - :tests ("(struct test (a b)")) - - ;;-- scheme - (:language "scheme" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define\\s+\\(\\s*JJJ\\j" - :tests ("(define (test blah)" - "(define (test\n") - :not ("(define test blah" - "(define (test-asdf blah)" - "(define test (lambda (blah")) - - (:language "scheme" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define\\s+JJJ\\s*\\\(\\s*lambda" - :tests ("(define test (lambda (blah" - "(define test (lambda\n") - :not ("(define test blah" - "(define test-asdf (lambda (blah)" - "(define (test)" - "(define (test blah) (lambda (foo")) - - (:language "scheme" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(let\\s+JJJ\\s*(\\\(|\\\[)*" - :tests ("(let test ((blah foo) (bar bas))" - "(let test\n" - "(let test [(foo") - :not ("(let ((test blah")) - - (:language "scheme" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define\\s+JJJ\\j" - :tests ("(define test " - "(define test\n") - :not ("(define (test")) - - (:language "scheme" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(\\\(|\\\[)\\s*JJJ\\s+" - :tests ("(let ((test 'foo" - "(let [(test 'foo" - "(let [(test 'foo" - "(let [[test 'foo" - "(let ((blah 'foo) (test 'bar)") - :not ("{test foo")) - - (:language "scheme" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(lambda\\s+\\\(?[^\(\)]*\\s*JJJ\\j\\s*\\\)?" - :tests ("(lambda (test)" - "(lambda (foo test)" - "(lambda test (foo)") - :not ("(lambda () test")) - - (:language "scheme" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\(define\\s+\\\([^\(\)]+\\s*JJJ\\j\\s*\\\)?" - :tests ("(define (foo test)" - "(define (foo test bar)") - :not ("(define foo test" - "(define (test foo" - "(define (test)")) - - ;;-- janet - (:language "janet" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(\(de\)?f\\s+JJJ\\j" - :tests ("(def test (foo)")) - - (:language "janet" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(var\\s+JJJ\\j" - :tests ("(var test (foo)")) - - (:language "janet" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(\(de\)fn-?\\s+JJJ\\j" - :tests ("(defn test [foo]" - "(defn- test [foo]") - :not ("(defn test? [foo]" - "(defn- test? [foo]")) - - (:language "janet" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(defmacro\\s+JJJ\\j" - :tests ("(defmacro test [foo]")) - - ;;-- c++ - (:language "c++" :type "function" - :supports ("ag" "rg" "git-grep") - :regex "\\bJJJ(\\s|\\))*\\((\\w|[,&*.<>:]|\\s)*(\\))\\s*(const|->|\\{|$)|typedef\\s+(\\w|[(*]|\\s)+JJJ(\\)|\\s)*\\(" - :tests ("int test(){" - "my_struct (*test)(int a, int b){" - "auto MyClass::test ( Builder::Builder& reference, ) -> decltype( builder.func() ) {" - "int test( int *random_argument) const {" - "test::test() {" - "typedef int (*test)(int);") - :not ("return test();)" - "int test(a, b);" - "if( test() ) {" - "else test();")) - - ;; (:language "c++" :type "variable" - ;; :supports ("grep") - ;; :regex "(\\b\\w+|[,>])([*&]|\\s)+JJJ\\s*(\\[([0-9]|\\s)*\\])*\\s*([=,){;]|:\\s*[0-9])|#define\\s+JJJ\\b" - ;; :tests ("int test=2;" "char *test;" "int x = 1, test = 2" "int test[20];" "#define test" "unsigned int test:2;")) - - (:language "c++" :type "variable" - :supports ("ag" "rg") - :regex "\\b(?!(class\\b|struct\\b|return\\b|else\\b|delete\\b))(\\w+|[,>])([*&]|\\s)+JJJ\\s*(\\[(\\d|\\s)*\\])*\\s*([=,(){;]|:\\s*\\d)|#define\\s+JJJ\\b" - :tests ("int test=2;" - "char *test;" - "int x = 1, test = 2" - "int test[20];" - "#define test" - "typedef int test;" - "unsigned int test:2") - :not ("return test;" - "#define NOT test" - "else test=2;")) - - (:language "c++" :type "type" - :supports ("ag" "rg" "git-grep") - :regex "\\b(class|struct|enum|union)\\b\\s*JJJ\\b\\s*(final\\s*)?(:((\\s*\\w+\\s*::)*\\s*\\w*\\s*<?(\\s*\\w+\\s*::)*\\w+>?\\s*,*)+)?((\\{|$))|}\\s*JJJ\\b\\s*;" - :tests ("typedef struct test {" - "enum test {" - "} test;" - "union test {" - "class test final: public Parent1, private Parent2{" - "class test : public std::vector<int> {") - :not("union test var;" - "struct test function() {")) - - ;;-- clojure - (:language "clojure" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(def.*\ JJJ\\j" - :tests ("(def test (foo)" - "(defn test [foo]" - "(defn ^:some-data test [foo]" - "(defn- test [foo]" - "(defmacro test [foo]" - "(deftask test [foo]" - "(deftype test [foo]" - "(defmulti test fn" - "(defmethod test type" - "(definterface test (foo)" - "(defprotocol test (foo)" - "(defrecord test [foo]" - "(deftest test")) - - ;;-- coffeescript - (:language "coffeescript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*JJJ\\s*[=:].*[-=]>" - :tests ("test = () =>" - "test= =>" - "test = ->" - "test=()->" - "test : () =>" - "test: =>" - "test : ->" - "test:()->") - :not ("# test = =>" - "test = 1")) - - (:language "coffeescript" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*JJJ\\s*[:=][^:=-][^>]+$" - :tests ("test = $" - "test : [" - "test = {" - "test = a") - :not ("test::a" - "test: =>" - "test == 1" - "# test = 1")) - - (:language "coffeescript" :type "class" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*\\bclass\\s+JJJ" - :tests ("class test" - "class test extends") - :not ("# class")) - - ;;-- objc : Objective-C - (:language "objc" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\)\\s*JJJ(:|\\b|\\s)" - :tests ("- (void)test" - "- (void)test:(UIAlertView *)alertView") - :not ("- (void)testnot" - "- (void)testnot:(UIAlertView *)alertView")) - - (:language "objc" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\b\\*?JJJ\\s*=[^=\\n]+" - :tests ("NSString *test = @\"asdf\"") - :not ("NSString *testnot = @\"asdf\"" - "NSString *nottest = @\"asdf\"")) - - (:language "objc" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(@interface|@protocol|@implementation)\\b\\s*JJJ\\b\\s*" - :tests ("@interface test: UIWindow") - :not ("@interface testnon: UIWindow")) - - - (:language "objc" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "typedef\\b\\s+(NS_OPTIONS|NS_ENUM)\\b\\([^,]+?,\\s*JJJ\\b\\s*" - :tests ("typedef NS_ENUM(NSUInteger, test)") - :not ("typedef NS_ENUMD(NSUInteger, test)")) - - ;;-- swift - (:language "swift" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(let|var)\\s*JJJ\\s*(=|:)[^=:\\n]+" - :tests ("let test = 1234" - "var test = 1234" - "private lazy var test: UITapGestureRecognizer") - :not ("if test == 1234:")) - - (:language "swift" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "func\\s+JJJ\\b\\s*(<[^>]*>)?\\s*\\(" - :tests ("func test(asdf)" - "func test()" - "func test<Value: Protocol>()") - :not ("func testnot(asdf)" - "func testnot()")) - - (:language "swift" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(class|struct|protocol|enum)\\s+JJJ\\b\\s*?" - :tests ("struct test" - "struct test: Codable" - "struct test<Value: Codable>" - "class test:" - "class test: UIWindow" - "class test<Value: Codable>") - :not ("class testnot:" - "class testnot(object):" - "struct testnot(object)")) - - (:language "swift" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(typealias)\\s+JJJ\\b\\s*?=" - :tests ("typealias test =") - :not ("typealias testnot")) - - ;;-- csharp : C# - (:language "csharp" :type "function" - :supports ("ag" "rg") - :regex "^\\s*(?:[\\w\\[\\]]+\\s+){1,3}JJJ\\s*\\\(" - :tests ("int test()" - "int test(param)" - "static int test()" - "static int test(param)" - "public static MyType test()" - "private virtual SomeType test(param)" - "static int test()") - :not ("test()" - "testnot()" - "blah = new test()")) - - (:language "csharp" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n)]+" - :tests ("int test = 1234") - :not ("if test == 1234:" - "int nottest = 44")) - - (:language "csharp" :type "variable" - :supports ("ag" "rg") - :regex "\\bforeach\\s*\\(\\s*[\\w\\[\\]<>,\\.?]+\\s+JJJ\\s+in\\b" - :tests ("foreach (int test in items)" - "foreach (var test in items)" - "foreach (string test in items)" - "foreach (List<int> test in items)") - :not ("foreach (int nottest in items)" - "test in items")) - - (:type "type" - :supports ("ag" "grep" "rg" "git-grep") - :language "csharp" - :regex "(class|interface)\\s*JJJ\\b" - :tests ("class test:" - "public class test : IReadableChannel, I") - :not ("class testnot:" - "public class testnot : IReadableChannel, I")) - - ;;-- java (literally the same regexes as c#, but different tests) - (:language "java" :type "function" - :supports ("ag" "rg") - :regex "^\\s*(?:[\\w\\[\\]]+\\s+){1,3}JJJ\\s*\\\(" - :tests ("int test()" - "int test(param)" - "static int test()" - "static int test(param)" - "public static MyType test()" - "private virtual SomeType test(param)" - "static int test()" - "private foo[] test()") - :not ("test()" - "testnot()" - "blah = new test()" - "foo bar = test()")) - - (:language "java" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n)]+" - :tests ("int test = 1234") - :not ("if test == 1234:" - "int nottest = 44")) - - (:language "java" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(class|interface)\\s*JJJ\\b" - :tests ("class test:" - "public class test implements Something") - :not ("class testnot:" - "public class testnot implements Something")) - - (:language "java" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\benum\\s+JJJ\\b" - :tests ("enum test {" - "public enum test {") - :not ("enum testnot {")) - - (:language "java" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "@interface\\s+JJJ\\b" - :tests ("@interface test {" - "public @interface test {") - :not ("@interface testnot {")) - - ;; grep/git-grep fallback: requires access modifier because grep lacks - ;; PCRE features (?:...) and {n,m} used by the ag/rg rule above. - (:language "java" :type "function" - :supports ("grep" "git-grep") - :regex "(public|protected|private|static)[^(]+JJJ\\s*\\\(" - :tests ("public int test()" - "private static String test(param)" - "protected List<String> test()") - :not ("test()" - "new test()")) - - ;;-- vala (again just like c#, exactly the same..) - (:language "vala" :type "function" - :supports ("ag" "rg") - :regex "^\\s*(?:[\\w\\[\\]]+\\s+){1,3}JJJ\\s*\\\(" - :tests ("int test()" - "int test(param)" - "static int test()" - "static int test(param)" - "public static MyType test()" - "private virtual SomeType test(param)" - "static int test()") - :not ("test()" - "testnot()" - "blah = new test()")) - - (:language "vala" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n)]+" - :tests ("int test = 1234") - :not ("if test == 1234:" - "int nottest = 44")) - - (:language "vala" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(class|interface)\\s*JJJ\\b" - :tests ("class test:" - "public class test : IReadableChannel, I") - :not ("class testnot:" - "public class testnot : IReadableChannel, I")) - - ;;-- coq (renamed Rocq in March 2025) - (:language "coq" :type "function" - :supports ("ag" "rg" "grep" "git-grep") - :regex "\\s*Variable\\s+JJJ\\b" - :tests ("Variable test") - :not ("Variable testx")) - - (:language "coq" :type "function" - :supports ("ag" "rg" "grep" "git-grep") - :regex "\\s*Inductive\\s+JJJ\\b" - :tests ("Inductive test") - :not ("Inductive testx")) - - (:language "coq" :type "function" - :supports ("ag" "rg" "grep" "git-grep") - :regex "\\s*Lemma\\s+JJJ\\b" - :tests ("Lemma test") - :not ("Lemma testx")) - - (:language "coq" :type "function" - :supports ("ag" "rg" "grep" "git-grep") - :regex "\\s*Definition\\s+JJJ\\b" - :tests ("Definition test") - :not ("Definition testx")) - - (:language "coq" :type "function" - :supports ("ag" "rg" "grep" "git-grep") - :regex "\\s*Hypothesis\\s+JJJ\\b" - :tests ("Hypothesis test") - :not ("Hypothesis testx")) - - (:language "coq" :type "function" - :supports ("ag" "rg" "grep" "git-grep") - :regex "\\s*Theorem\\s+JJJ\\b" - :tests ("Theorem test") - :not ("Theorem testx")) - - (:language "coq" :type "function" - :supports ("ag" "rg" "grep" "git-grep") - :regex "\\s*Fixpoint\\s+JJJ\\b" - :tests ("Fixpoint test") - :not ("Fixpoint testx")) - - (:language "coq" :type "function" - :supports ("ag" "rg" "grep" "git-grep") - :regex "\\s*Module\\s+JJJ\\b" - :tests ("Module test") - :not ("Module testx")) - - (:language "coq" :type "function" - :supports ("ag" "rg" "git-grep") - :regex "\\s*CoInductive\\s+JJJ\\b" - :tests ("CoInductive test") - :not ("CoInductive testx")) - - ;;-- python - (:language "python" :type "variable" - :supports ("ag" "rg") - :regex "\\s*\\bJJJ\\b(\\s*:[^=\\n]+)?\\s*=[^=\\n]+" - :tests ("test = 1234" - "test: int = 1234" - "test: int | None = 1234" - "test: List[Optional[int]] = [1234, None]") - :not ("if test == 1234:" - "_test = 1234" - "if (test := 3):" - "while test:" - "test['key'] = 1234")) - - (:language "python" :type "variable" - :supports ("grep" "git-grep") - :regex "\\s*\\bJJJ\\b(\\s*:[^=]+)?\\s*=[^=]+" - :tests ("test = 1234" - "test: int = 1234" - "test: int | None = 1234" - "test: List[Optional[int]] = [1234, None]") - :not ("if test == 1234:" - "_test = 1234" - "if (test := 3):" - "while test:" - "test['key'] = 1234")) - - (:language "python" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "def\\s*JJJ\\b\\s*\\\(" - :tests ("\tdef test(asdf)" - "def test()") - :not ("\tdef testnot(asdf)" - "def testnot()")) - - (:language "python" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ\\b\\s*\\\(?" - :tests ("class test(object):" - "class test:") - :not ("class testnot:" - "class testnot(object):")) - - (:language "python" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "async\\s+def\\s*JJJ\\b\\s*\\\(" - :tests ("async def test(param)" - "async def test()") - :not ("async def testnot(param)" - "async def testnot()")) - - (:language "python" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*JJJ\\s*=\\s*lambda\\b" - :tests ("test = lambda x: x" - "test = lambda: None") - :not ("testnot = lambda x: x" - "foo(test=lambda x: x)")) - - ;;-- matlab - (:language "matlab" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*\\bJJJ\\s*=[^=\\n]+" - :tests ("test = 1234") - :not ("for test = 1:2:" - "_test = 1234")) - - (:language "matlab" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*function\\s*[^=]+\\s*=\\s*JJJ\\b" - :tests ("\tfunction y = test(asdf)" - "function x = test()" - "function [x, losses] = test(A, y, lambda, method, qtile)") - :not ("\tfunction testnot(asdf)" - "function testnot()")) - - (:language "matlab" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*classdef\\s*JJJ\\b\\s*" - :tests ("classdef test") - :not ("classdef testnot")) - - ;;-- nim - (:language "nim" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(const|let|var)\\s*JJJ\\*?\\s*(=|:)[^=:\\n]+" - :tests ("let test = 1234" - "var test = 1234" - "var test: Stat" - "const test = 1234" - "const test* = 1234") - :not ("if test == 1234:")) - - (:language "nim" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(proc|func|macro|template)\\s*`?JJJ`?\\b\\*?\\s*\\\(" - :tests ("\tproc test(asdf)" - "proc test()" - "func test()" - "macro test()" - "template test()" - "proc test*()") - :not ("\tproc testnot(asdf)" - "proc testnot()")) - - (:language "nim" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "type\\s*JJJ\\b\\*?\\s*(\\{[^}]+\\})?\\s*=\\s*\\w+" - :tests ("type test = object" - "type test {.pure.} = enum" - "type test* = ref object") - :not ("type testnot = object")) - - ;;-- nix - (:language "nix" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\b\\s*JJJ\\s*=[^=;]+" - :tests ("test = 1234;" - "test = 123;" - "test=123") - :not ("testNot = 1234;" - "Nottest = 1234;" - "AtestNot = 1234;")) - - ;;-- org - ;; org named blocks - (:language "org" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*#\\+[nN][aA][mM][eE]:\\s*JJJ\\j" - :tests ("#+name: test" - "#+NAME: test" - "#+Name: test" - " #+name: test" - "#+name:test") - :not ("#+name: tester" - "#+name: test-block" - "some #+name: test")) - - ;; org call references (#+call: block-name) - (:language "org" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*#\\+[cC][aA][lL][lL]:\\s*JJJ\\j" - :tests ("#+call: test" - "#+CALL: test" - "#+Call: test" - " #+call: test" - "#+call: test()" - "#+call: test(x=1)") - :not ("#+call: tester" - "#+call: test-other" - "some #+call: test")) - - ;; org headings (* Heading text) - (:language "org" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\*+\\s+JJJ\\j" - :tests ("* test" - "** test" - "*** test" - "**** test" - "* test heading" - "** test with more words") - :not ("* tester" - "** testing" - "* test-other" - "not a * test heading")) - - ;; org custom ID (:CUSTOM_ID: value in property drawers) - (:language "org" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*:CUSTOM_ID:\\s*JJJ\\j" - :tests (":CUSTOM_ID: test" - ":CUSTOM_ID: test" - " :CUSTOM_ID: test" - ":CUSTOM_ID:test") - :not (":CUSTOM_ID: tester" - ":CUSTOM_ID: test-other" - "inline :CUSTOM_ID: test text")) - - ;;-- ruby - (:language "ruby" :type "variable" - :supports ("ag" "rg" "git-grep") - :regex "^\\s*((\\w+[.])*\\w+,\\s*)*JJJ(,\\s*(\\w+[.])*\\w+)*\\s*=([^=>~]|$)" - :tests ("test = 1234" - "self.foo, test, bar = args") - :not ("if test == 1234" - "foo_test = 1234")) - - (:language "ruby" :type "function" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])((private|public|protected)\\s+)?def\\s+(\\w+(::|[.]))*JJJ($|[^\\w|:])" - :tests ("def test(foo)" - "def test()" - "def test foo" - "def test; end" - "def self.test()" - "def MODULE::test()" - "private def test") - :not ("def test_foo")) - - (:language "ruby" :type "function" - :supports ("ag" "rg" "git-grep") - :regex "(^|\\W)define(_singleton|_instance)?_method(\\s|[(])\\s*:JJJ($|[^\\w|:])" - :tests ("define_method(:test, &body)" - "mod.define_instance_method(:test) { body }")) - - (:language "ruby" :type "type" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])class\\s+(\\w*::)*JJJ($|[^\\w|:])" - :tests ("class test" - "class Foo::test")) - - (:language "ruby" :type "type" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])module\\s+(\\w*::)*JJJ($|[^\\w|:])" - :tests ("module test" - "module Foo::test")) - - (:language "ruby" :type "function" - :supports ("ag" "rg" "git-grep") - :regex "(^|\\W)alias(_method)?\\W+JJJ(\\W|$)" - :tests ("alias test some_method" - "alias_method :test, :some_method" - "alias_method 'test' 'some_method'" - "some_class.send(:alias_method, :test, :some_method)") - :not ("alias some_method test" - "alias_method :some_method, :test" - "alias test_foo test")) - - ;;-- Groovy - (:language "groovy" :type "variable" - :supports ("ag" "rg" "git-grep") - :regex "^\\s*((\\w+[.])*\\w+,\\s*)*JJJ(,\\s*(\\w+[.])*\\w+)*\\s*=([^=>~]|$)" - :tests ("test = 1234" - "self.foo, test, bar = args") - :not ("if test == 1234" - "foo_test = 1234")) - - (:language "groovy" :type "function" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])((private|public)\\s+)?def\\s+(\\w+(::|[.]))*JJJ($|[^\\w|:])" - :tests ("def test(foo)" - "def test()" - "def test foo" - "def test; end" - "def self.test()" - "def MODULE::test()" - "private def test") - :not ("def test_foo")) - - (:language "groovy" :type "type" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])class\\s+(\\w*::)*JJJ($|[^\\w|:])" - :tests ("class test" - "class Foo::test")) - - ;;-- crystal - (:language "crystal" :type "variable" - :supports ("ag" "rg" "git-grep") - :regex "^\\s*((\\w+[.])*\\w+,\\s*)*JJJ(,\\s*(\\w+[.])*\\w+)*\\s*=([^=>~]|$)" - :tests ("test = 1234" - "self.foo, test, bar = args") - :not ("if test == 1234" - "foo_test = 1234")) - - (:language "crystal" :type "function" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])((private|public|protected)\\s+)?def\\s+(\\w+(::|[.]))*JJJ($|[^\\w|:])" - :tests ("def test(foo)" - "def test()" - "def test foo" - "def test; end" - "def self.test()" - "def MODULE::test()" - "private def test") - :not ("def test_foo")) - - (:language "crystal" :type "type" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])class\\s+(\\w*::)*JJJ($|[^\\w|:])" - :tests ("class test" - "class Foo::test")) - - (:language "crystal" :type "type" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])module\\s+(\\w*::)*JJJ($|[^\\w|:])" - :tests ("module test" - "module Foo::test")) - - (:language "crystal" :type "type" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])struct\\s+(\\w*::)*JJJ($|[^\\w|:])" - :tests ("struct test" - "struct Foo::test")) - - (:language "crystal" :type "type" - :supports ("ag" "rg" "git-grep") - :regex "(^|[^\\w.])alias\\s+(\\w*::)*JJJ($|[^\\w|:])" - :tests ("alias test" - "alias Foo::test")) - - ;;-- scad - (:language "scad" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n]+" - :tests ("test = 1234") - :not ("if test == 1234 {")) - - (:language "scad" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "function\\s*JJJ\\s*\\\(" - :tests ("function test()" - "function test ()")) - - (:language "scad" :type "module" - :supports ("ag" "grep" "rg" "git-grep") - :regex "module\\s*JJJ\\s*\\\(" - :tests ("module test()" - "module test ()")) - - ;;-- scala - (:language "scala" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bval\\s*JJJ\\s*=[^=\\n]+" - :tests ("val test = 1234") - :not ("case test => 1234")) - - (:language "scala" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bvar\\s*JJJ\\s*=[^=\\n]+" - :tests ("var test = 1234") - :not ("case test => 1234")) - - (:language "scala" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\btype\\s*JJJ\\s*=[^=\\n]+" - :tests ("type test = 1234") - :not ("case test => 1234")) - - (:language "scala" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bdef\\s*JJJ\\s*\\\(" - :tests ("def test(asdf)" "def test()")) - - (:language "scala" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ\\s*\\\(?" - :tests ("class test(object)")) - - (:language "scala" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "trait\\s*JJJ\\s*\\\(?" - :tests ("trait test(object)")) - - (:language "scala" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "object\\s*JJJ\\s*\\\(?" - :tests ("object test(object)")) - - ;;-- solidity - (:language "solidity" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "function\\s*JJJ\\s*\\\(" - :tests ("function test() internal" - "function test (uint x, address y)" - "function test() external")) - - (:language "solidity" :type "modifier" - :supports ("ag" "grep" "rg" "git-grep") - :regex "modifier\\s*JJJ\\s*\\\(" - :tests ("modifier test()" - "modifier test ()")) - - (:language "solidity" :type "event" - :supports ("ag" "grep" "rg" "git-grep") - :regex "event\\s*JJJ\\s*\\\(" - :tests ("event test();" - "event test (uint indexed x)" - "event test(uint x, address y)")) - - (:language "solidity" :type "error" - :supports ("ag" "grep" "rg" "git-grep") - :regex "error\\s*JJJ\\s*\\\(" - :tests ("error test();" - "error test (uint x)" - "error test(uint x, address y)")) - - (:language "solidity" :type "contract" - :supports ("ag" "grep" "rg" "git-grep") - :regex "contract\\s*JJJ\\s*(is|\\\{)" - :tests ("contract test{" - "contract test {" - "contract test is foo")) - - (:language "solidity" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "struct\\s*JJJ\\s*\\\{" - :tests ("struct test{" - "struct test {")) - - ;;-- R - (:language "r" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*=[^=><]" - :tests ("test = 1234") - :not ("if (test == 1234)")) - - (:language "r" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*<-\\s*function\\b" - :tests ("test <- function" - "test <- function(") - :not ("test <- functionX")) - - ;;-- perl - (:language "perl" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "sub\\s*JJJ\\s*(\\{|\\()" - :tests ("sub test{" - "sub test {" - "sub test(" "sub test (")) - - (:language "perl" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "JJJ\\s*=\\s*" - :tests ("$test = 1234")) - - ;;-- Tcl - (:language "tcl" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "proc\\s+JJJ\\s*\\{" - :tests ("proc test{" "proc test {")) - - (:language "tcl" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "set\\s+JJJ" - :tests ("set test 1234")) - - (:language "tcl" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(variable|global)\\s+JJJ" - :tests ("variable test" "global test")) - - ;;-- shell - (:language "shell" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "function\\s*JJJ\\s*" - :tests ("function test{" - "function test {" - "function test () {") - :not ("function nottest {")) - - (:language "shell" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "JJJ\\\(\\\)\\s*\\{" - :tests ("test() {") - :not ("testx() {")) - - (:language "shell" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*=\\s*" - :tests ("test = 1234") - :not ("blahtest = 1234")) - - ;;-- php - (:language "php" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "function\\s*JJJ\\s*\\\(" - :tests ("function test()" - "function test ()")) - - (:language "php" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\*\\s@method\\s+[^ \t]+\\s+JJJ\\(" - :tests ("/** @method string|false test($a)" - " * @method bool test()")) - - (:language "php" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(\\s|->|\\$|::)JJJ\\s*=\\s*" - :tests ("$test = 1234" - "$foo->test = 1234")) - - (:language "php" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\*\\s@property(-read|-write)?\\s+([^ \t]+\\s+)&?\\$JJJ(\\s+|$)" - :tests ("/** @property string $test" - "/** @property string $test description for $test property" - " * @property-read bool|bool $test" - " * @property-write \\ArrayObject<string,resource[]> $test")) - - (:language "php" :type "trait" - :supports ("ag" "grep" "rg" "git-grep") - :regex "trait\\s*JJJ\\s*\\\{" - :tests ("trait test{" - "trait test {")) - - (:language "php" :type "interface" - :supports ("ag" "grep" "rg" "git-grep") - :regex "interface\\s*JJJ\\s*(extends|\\\{)" - :tests ("interface test{" - "interface test {") - "interface test extends test2") - - (:language "php" :type "class" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ\\s*(extends|implements|\\\{)" - :tests ("class test{" - "class test {" - "class test extends foo" - "class test implements foo")) - - ;; PHP 8.1+ enum definition - (:language "php" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\benum\\s+JJJ\\b\\s*(:\\s*(int|string))?\\s*(implements[^{]+)?\\{" - :tests ("enum test {" - "enum test: int {" - "enum test: string {" - "enum test implements Stringable {" - "enum test: int implements JsonSerializable {") - :not ("// enum test" "$enum = 'test'")) - - ;; PHP 8.1+ enum case - (:language "php" :type "constant" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*case\\s+JJJ\\s*(;|=)" - :tests (" case test;" - "case test = 1;" - "case test = 'value';") - :not ("case 'test':" "case \"test\":" "default:")) - - ;; PHP abstract class - (:language "php" :type "class" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\babstract\\s+class\\s+JJJ\\s*(extends|implements|\\\{)" - :tests ("abstract class test {" - "abstract class test extends Base {" - "abstract class test implements Foo {") - :not ("// abstract class test")) - - ;; PHP final class (including final readonly) - (:language "php" :type "class" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bfinal\\s+(readonly\\s+)?class\\s+JJJ\\s*(extends|implements|\\\{)" - :tests ("final class test {" - "final readonly class test {" - "final class test extends Base {") - :not ("// final class test")) - - ;; PHP readonly class (including readonly final) - (:language "php" :type "class" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\breadonly\\s+(final\\s+)?class\\s+JJJ\\s*(extends|implements|\\\{)" - :tests ("readonly class test {" - "readonly final class test {" - "readonly class test implements Serializable {") - :not ("// readonly class test")) - - ;; PHP class constant with optional visibility/final - (:language "php" :type "constant" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(final\\s+)?(public|protected|private)?\\s*const\\s+JJJ\\s*=" - :tests ("const test = 'value';" - "public const test = 100;" - "private const test = 'secret';" - "protected const test = [];" - "final public const test = 42;" - "final const test = true;") - :not ("$const = 'test'" "// const test")) - - ;; PHP global const (outside class) - (:language "php" :type "constant" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^const\\s+JJJ\\s*=" - :tests ("const test = 'app_name';" - "const test = 42;" - "const test = [];") - :not (" const test =" "public const test =")) - - ;; PHP define() function - (:language "php" :type "constant" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*define\\s*\\(\\s*['\"]JJJ['\"]" - :tests ("define('test', 100);" - "define(\"test\", 'value');" - "define('test',") - :not ("// define('test'" "$define = 'test'")) - - ;; PHP typed property declaration - (:language "php" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(public|protected|private)\\s+(static\\s+)?(readonly\\s+)?\\??[A-Za-z_][A-Za-z0-9_\\\\|&]*\\s+\\$JJJ\\s*(;|=|,)" - :tests ("public int $test;" - "private string $test = '';" - "protected ?array $test = null;" - "public readonly string $test;" - "private static int $test = 0;" - "public DateTime $test;") - :not ("public function foo(int $test)" "return $test;")) - - ;; PHP static property (without explicit type) - (:language "php" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(public|protected|private)?\\s*static\\s+\\$JJJ\\s*(;|=)" - :tests ("static $test;" - "public static $test = [];" - "private static $test = null;") - :not ("static function test()" "static::$test")) - - ;; PHP namespace declaration - (:language "php" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bnamespace\\s+([A-Za-z_][A-Za-z0-9_]*\\\\)*JJJ\\s*[;{]" - :tests ("namespace test;" - "namespace App\\test;" - "namespace App\\Services\\test {") - :not ("// namespace test" "use App\\test;")) - - ;; PHP use statement for class imports - (:language "php" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\buse\\s+([A-Za-z_][A-Za-z0-9_]*\\\\)*JJJ\\s*(;|,|\\s+as\\s+)" - :tests ("use test;" - "use App\\test;" - "use App\\Models\\test as TestModel;" - "use App\\test, App\\Other;") - :not ("use function test;" "use const test;")) - - ;;-- dart - (:language "dart" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*\\([^()]*\\)\\s*[{]" - :tests ("test(foo) {" - "test (foo){" - "test(foo){")) - - (:language "dart" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ\\s*[\\\(\\\{]" - :tests ("class test(object) {" - "class test{")) - - ;;-- dlang - (:language "dlang" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^[[:space:]]*([][[:alnum:]_!.*<>]+[[:space:]]+)+JJJ[[:space:]]*\\\([^;{}]*\\\)([[:space:]]+@?[[:alnum:]_]+)*[[:space:]]*[{]" - :tests ("void test() {" - "public static int test(int value) {" - "auto test(T)(T value) {" - "void test() pure {" - "void test() @safe {") - :not ("return test();" - "auto value = test(arg);" - "test();")) - - (:language "dlang" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n)]+" - :tests ("int test = 1234;" - "immutable test = 1;" - "auto test = foo();") - :not ("if (test == 1234)" - "int nottest = 44;")) - - (:language "dlang" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(class|interface|struct|union|enum|alias)\\s+JJJ\\b" - :tests ("class test {" - "struct test {" - "alias test = int;") - :not ("class testnot {" - "alias nottest = test;")) - - ;;-- faust - (:language "faust" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\(\\\(.+\\\)\)*\\s*=" - :tests ("test = osc + 0.5;" - "test(freq) = osc(freq) + 0.5;")) - - ;;-- fennel - (:language "fennel" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\((local|var)\\s+JJJ\\j" - :tests ("(local test (foo)" - "(var test (foo)")) - - (:language "fennel" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(fn\\s+JJJ\\j" - :tests ("(fn test [foo]") - :not ("(fn test? [foo]")) - - (:language "fennel" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\(macro\\s+JJJ\\j" - :tests ("(macro test [foo]")) - - ;;-- fortran - (:language "fortran" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n]+" - :tests ("test = 1234") - :not ("if (test == 1234)")) - - (:language "fortran" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\b(function|subroutine|FUNCTION|SUBROUTINE)\\s+JJJ\\b\\s*\\\(" - :tests ("function test (foo)" - "integer function test(foo)" - "subroutine test (foo, bar)" - "FUNCTION test (foo)" - "INTEGER FUNCTION test(foo)" - "SUBROUTINE test (foo, bar)") - :not ("end function test" - "end subroutine test" - "END FUNCTION test" - "END SUBROUTINE test")) - - (:language "fortran" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*(interface|INTERFACE)\\s+JJJ\\b" - :tests ("interface test" - "INTERFACE test") - :not ("interface test2" - "end interface test" - "INTERFACE test2" - "END INTERFACE test")) - - (:language "fortran" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*(module|MODULE)\\s+JJJ\\s*" - :tests ("module test" - "MODULE test") - :not ("end module test" - "END MODULE test")) - - ;;-- go - (:language "go" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n]+" - :tests ("test = 1234") - :not ("if test == 1234 {")) - - (:language "go" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*:=\\s*" - :tests ("test := 1234")) - - (:language "go" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "func\\s+\\\([^\\\)]*\\\)\\s+JJJ\\s*\\\(" - :tests ("func (s *blah) test(filename string) string {")) - - (:language "go" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "func\\s+JJJ\\s*\\\(" - :tests ("func test(url string) (string, error)")) - - (:language "go" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "type\\s+JJJ\\s+struct\\s+\\\{" - :tests ("type test struct {")) - - (:language "go" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "type\\s+JJJ(\\\[[^]]+\\\])?\\s+interface\\s*\\\{" - :tests ("type test interface {" - "type test[T comparable] interface {") - :not ("type testnot interface {")) - - (:language "go" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "type\\s+JJJ(\\\[[^]]+\\\])?\\s+" - :tests ("type test int" - "type test[T any] []byte" - "type test = string" - "type test []byte" - "type test string") - :not ("type testnot int")) - - ;;-- javascript extended - (:language "javascript" :tags ("angular") :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(service|factory)\\\(['\"]JJJ['\"]" - :tests ("module.factory('test', [\"$rootScope\", function($rootScope) {")) - - (:language "javascript" :tags ("es6") :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*[=:]\\s*\\\([^\\\)]*\\\)\\s+=>" - :tests ("const test = (foo) => " "test: (foo) => {" " test: (foo) => {")) - - (:language "javascript" :tags ("es6") :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*\\([^()]*\\)\\s*[{]" - :tests ("test(foo) {" "test (foo){" "test(foo){") - :not ("test = blah.then(function(){")) - - (:language "javascript" :tags ("es6") :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ\\s*[\\\(\\\{]" - :tests ("class test(object) {" "class test{")) - - (:language "javascript" :tags ("es6") :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ\\s+extends" - :tests ("class test extends Component{")) - - ;;-- javascript - (:language "javascript" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n]+" - :tests ("test = 1234" - "const test = props =>") - :not ("if (test === 1234)")) - - (:language "javascript" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bfunction\\b[^\\(]*\\\(\\s*[^\\)]*\\bJJJ\\b\\s*,?\\s*\\\)?" - :tests ("function (test)" - "function (test, blah)" - "function somefunc(test, blah) {" - "function(blah, test)") - :not ("function (testLen)" - "function (test1, blah)" - "function somefunc(testFirst, blah) {" - "function(blah, testLast)" - "function (Lentest)" - "function (blahtest, blah)" - "function somefunc(Firsttest, blah) {" - "function(blah, Lasttest)")) - - (:language "javascript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "function\\s*JJJ\\s*\\\(" - :tests ("function test()" - "function test ()")) - - (:language "javascript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*:\\s*function\\s*\\\(" - :tests ("test: function()")) - - (:language "javascript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*=\\s*function\\s*\\\(" - :tests ("test = function()")) - - ;;-- hcl terraform - (:language "hcl" :type "block" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(variable|output|module)\\s*\"JJJ\"\\s*\\\{" - :tests ("variable \"test\" {" - "output \"test\" {" - "module \"test\" {")) - - (:language "hcl" :type "block" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(data|resource)\\s*\"\\w+\"\\s*\"JJJ\"\\s*\\\{" - :tests ("data \"openstack_images_image_v2\" \"test\" {" - "resource \"google_compute_instance\" \"test\" {")) - - ;;-- typescript - (:language "typescript" :tags ("angular") :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(service|factory)\\\(['\"]JJJ['\"]" - :tests ("module.factory('test', [\"$rootScope\", function($rootScope) {")) - - (:language "typescript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*[=:]\\s*\\\([^\\\)]*\\\)\\s+=>" - :tests ("const test = (foo) => " - "test: (foo) => {" - " test: (foo) => {")) - - (:language "typescript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*\\([^()]*\\)\\s*[{]" - :tests ("test(foo) {" - "test (foo){" - "test(foo){") - :not ("test = blah.then(function(){")) - - (:language "typescript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ(\\s*<[^>]*>)?\\s*[\\\(\\\{]" - :tests ("class test{" - "class test<T>{")) - - (:language "typescript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ(\\s*<[^>]*>)?\\s+extends" - :tests ("class test extends Component{" - "class test<T> extends Component{")) - - (:language "typescript" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ(\\s*<[^>]*>)?\\s*[\\\(\\\{]" - :tests ("class test{" - "class test<T>{")) - - (:language "typescript" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "class\\s*JJJ(\\s*<[^>]*>)?\\s+extends" - :tests ("class test extends Component{" - "class test<T> extends Component{")) - - (:language "typescript" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(export\\s+)?interface\\s+JJJ\\b" - :tests ("interface test{" - "interface test extends Thing{" - "export interface test{") - :not ("interface testnot{")) - - (:language "typescript" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(export\\s+)?type\\s+JJJ\\b" - :tests ("type test = number" - "type test<T> = T" - "export type test = number") - :not ("type testnot = number")) - - (:language "typescript" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(export\\s+)?enum\\s+JJJ\\b" - :tests ("enum test{" - "export enum test{") - :not ("enum testnot{")) - - (:language "typescript" :type "module" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(declare\\s+)?namespace\\s+JJJ\\b" - :tests ("declare namespace test" - "namespace test") - :not ("declare testnot")) - - (:language "typescript" :type "module" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(export\\s+)?module\\s+JJJ\\b" - :tests ("export module test" - "module test") - :not ("module testnot")) - - (:language "typescript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "function\\s*JJJ\\s*\\\(" - :tests ("function test()" - "function test ()")) - - (:language "typescript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*:\\s*function\\s*\\\(" - :tests ("test: function()")) - - (:language "typescript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*=\\s*function\\s*\\\(" - :tests ("test = function()")) - - (:language "typescript" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n]+" - :tests ("test = 1234" "const test = props =>") - :not ("if (test === 1234)")) - - (:language "typescript" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bfunction\\b[^\\(]*\\\(\\s*[^\\)]*\\bJJJ\\b\\s*,?\\s*\\\)?" - :tests ("function (test)" - "function (test, blah)" - "function somefunc(test, blah) {" - "function(blah, test)") - :not ("function (testLen)" - "function (test1, blah)" - "function somefunc(testFirst, blah) {" - "function(blah, testLast)" - "function (Lentest)" - "function (blahtest, blah)" - "function somefunc(Firsttest, blah) {" - "function(blah, Lasttest)")) - - ;;-- julia - (:language "julia" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(@noinline|@inline)?\\s*function\\s*JJJ(\\{[^\\}]*\\})?\\(" - :tests ("function test()" - "@inline function test()" - "function test{T}(h)")) - - (:language "julia" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(@noinline|@inline)?JJJ(\\{[^\\}]*\\})?\\([^\\)]*\\)\s*=" - :tests ("test(a)=1" - "test(a,b)=1*8" - "@noinline test()=1" - "test{T}(x)=x")) - - (:language "julia" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "macro\\s*JJJ\\(" - :tests ("macro test(a)=1" - " macro test(a,b)=1*8")) - - (:language "julia" :type "variable" - :supports ("ag" "rg") - :regex "const\\s+JJJ\\b" - :tests ("const test = ")) - - (:language "julia" :type "type" - :supports ("ag" "rg") - :regex "(mutable)?\\s*struct\\s*JJJ" - :tests ("struct test")) - - (:language "julia" :type "type" - :supports ("ag" "rg") - :regex "(type|immutable|abstract)\\s*JJJ" - :tests ("type test" - "immutable test" - "abstract test <:Testable" )) - - ;;-- haskell - (:language "haskell" :type "module" - :supports ("ag" "rg" "grep" "git-grep") - :regex "^module\\s+JJJ\\s+" - :tests ("module test (exportA, exportB) where") - :not ("-- module test" "import test")) - - ; TODO Doesn't support any '=' in arguments. E.g. 'foo A{a = b,..} = bar'. - (:language "haskell" :type "top level function" - :supports ("ag" "rg") - :regex "^\\bJJJ(?!(\\s+::))\\s+((.|\\s)*?)=\\s+" - :tests ("test n = n * 2" - "test X{..} (Y a b c) \n bcd \n =\n x * y" - "test ab cd e@Datatype {..} (Another thing, inTheRow) = \n undefined" - "test = runRealBasedMode @ext @ctx identity identity" - "test unwrap wrap nr@Naoeu {..} (Action action, specSpecs) = \n undefined") - :not ("nottest n = n * 2" - "let testnot x y = x * y" - "test $ y z" - "let test a o = mda" - "test :: Sometype -> AnotherType aoeu kek = undefined")) - - (:language "haskell" :type "type-like" - :supports ("ag" "rg" "grep" "git-grep") - :regex "^\\s*((data(\\s+family)?)|(newtype)|(type(\\s+family)?))\\s+JJJ\\s+" - :tests ("newtype test a = Something { b :: Kek }" - "data test a b = Somecase a | Othercase b" - "type family test (x :: *) (xs :: [*]) :: Nat where" - "data family test " - "type test = TestAlias") - :not ("newtype nottest a = nottest (Not a)" - "data testnot b = Aoeu")) - - ; datatype contstuctor that doesn't match type definition. - (:language "haskell" :type "(data)type constructor 1" - :supports ("ag" "rg") - :regex "(data|newtype)\\s{1,3}(?!JJJ\\s+)([^=]{1,40})=((\\s{0,3}JJJ\\s+)|([^=]{0,500}?((?<!(-- ))\\|\\s{0,3}JJJ\\s+)))" - :tests ("data Something a = test { b :: Kek }" - "data Mem a = TrueMem { b :: Kek } | test (Mem Int) deriving Mda" - "newtype SafeTest a = test (Kek a) deriving (YonedaEmbedding)") - :not ("data test = test { b :: Kek }")) - - - (:language "haskell" :type "data/newtype record field" - :supports ("ag" "rg") - :regex "(data|newtype)([^=]*)=[^=]*?({([^=}]*?)(\\bJJJ)\\s+::[^=}]+})" - :tests ("data Mem = Mem { \n mda :: A \n , test :: Kek \n , \n aoeu :: E \n }" - "data Mem = Mem { \n test :: A \n , mda :: Kek \n , \n aoeu :: E \n }" - "data Mem = Mem { \n mda :: A \n , aoeu :: Kek \n , \n test :: E \n }" - "data Mem = Mem { test :: Kek } deriving Mda" - "data Mem = Mem { \n test :: Kek \n } deriving Mda" - "newtype Mem = Mem { \n test :: Kek \n } deriving (Eq)" - "newtype Mem = Mem { -- | Some docs \n test :: Kek -- ^ More docs } deriving Eq" - "newtype Mem = Mem { test :: Kek } deriving (Eq,Monad)" - "newtype NewMem = OldMem { test :: [Tx] }" - "newtype BlockHeaderList ssc = BHL\n { test :: ([Aoeu a], [Ssss])\n } deriving (Eq)") - :not ("data Heh = Mda { sometest :: Kek, testsome :: Mem }")) - - (:language "haskell" :type "typeclass" - :supports ("ag" "rg" "grep" "git-grep") - :regex "^class\\s+(.+=>\\s*)?JJJ\\s+" - :tests ( - "class (Constr1 m, Constr 2) => test (Kek a) where" - "class test (Veryovka a) where ") - :not ("class test2 (Kek a) where" - "class maketest (AoeuTest x y z) where")) - - ;;-- ocaml - (:language "ocaml" :type "type" - :supports ("ag" "rg" "grep" "git-grep") - :regex "^\\s*(and|type)\\s+.*\\bJJJ\\b" - :tests ("type test =" - "and test =" - "type 'a test =" - "type ('a, _, 'c) test")) - - (:language "ocaml" :type "variable" - :supports ("ag" "rg" "grep" "git-grep") - :regex "let\\s+JJJ\\b" - :tests ("let test =" - "let test x y =")) - - (:language "ocaml" :type "variable" - :supports ("ag" "rg" "grep" "git-grep") - :regex "let\\s+rec\\s+JJJ\\b" - :tests ("let rec test =" - "let rec test x y =")) - - (:language "ocaml" :type "variable" - :supports ("ag" "rg" "grep" "git-grep") - :regex "\\s*val\\s*\\bJJJ\\b\\s*" - :tests ("val test")) - - (:language "ocaml" :type "module" - :supports ("ag" "rg" "grep" "git-grep") - :regex "^\\s*module\\s*\\bJJJ\\b" - :tests ("module test =")) - - (:language "ocaml" :type "module" - :supports ("ag" "rg" "grep" "git-grep") - :regex "^\\s*module\\s*type\\s*\\bJJJ\\b" - :tests ("module type test =")) - - ;;-- purescript - (:language "purescript" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*\\bJJJ\\b\\s+(::|[^=]*\\s=[^=])" - :tests ("test :: Int -> String" - "test :: Number -> Number -> Number" - " test :: Int -> String" - "test x y = x + y" - "test (Just x) = x" - "test { x } = x") - :not ("nottest :: Int -> String" - "testing x = 1" - "test x == y" - "test >>= bar")) - - (:language "purescript" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*\\bJJJ\\s*=[^=]" - :tests ("test = 42" - "test = \\x -> x + 1" - " test = compute x") - :not ("test == 42" - "-- test = 42")) - - (:language "purescript" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\blet\\s+JJJ\\s*(\\::|=[^=])" - :tests ("let test = 42" - "let test :: Int") - :not ("let testing = 42" - "let test == 42")) - - (:language "purescript" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^\\s*(type|newtype|data)\\s+JJJ\\b" - :tests ("type test = Int" - "newtype test = test Int" - "data test = test Int | Other String") - :not ("type testOther = Int" - "data testOther = testOther Int")) - - ;; lua - (:language "lua" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n]+" - :tests ("test = 1234") - :not ("if test === 1234")) - - (:language "lua" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bfunction\\b[^\\(]*\\\(\\s*[^\\)]*\\bJJJ\\b\\s*,?\\s*\\\)?" - :tests ("function (test)" - "function (test, blah)" - "function somefunc(test, blah)" - "function(blah, test)") - :not ("function (testLen)" - "function (test1, blah)" - "function somefunc(testFirst, blah)" - "function(blah, testLast)" - "function (Lentest)" - "function (blahtest, blah)" - "function somefunc(Firsttest, blah)" - "function(blah, Lasttest)")) - - (:language "lua" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "function\\s*JJJ\\s*\\\(" - :tests ("function test()" "function test ()")) - - (:language "lua" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "function\\s*.+[.:]JJJ\\s*\\\(" - :tests ("function MyClass.test()" - "function MyClass.test ()" - "function MyClass:test()" - "function MyClass:test ()")) - - (:language "lua" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*=\\s*function\\s*\\\(" - :tests ("test = function()")) - - (:language "lua" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\b.+\\.JJJ\\s*=\\s*function\\s*\\\(" - :tests ("MyClass.test = function()")) - - ;;-- rust - (:language "rust" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\blet\\s+(\\\([^=\\n]*)?(mut\s+)?JJJ([^=\\n]*\\\))?(:\\s*[^=\\n]+)?\\s*=\\s*[^=\\n]+" - :tests ("let test = 1234;" - "let test: u32 = 1234;" - "let test: Vec<u32> = Vec::new();" - "let mut test = 1234;" - "let mut test: Vec<u32> = Vec::new();" - "let (a, test, b) = (1, 2, 3);" - "let (a, mut test, mut b) = (1, 2, 3);" - "let (mut a, mut test): (u32, usize) = (1, 2);")) - - (:language "rust" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bconst\\s+JJJ:\\s*[^=\\n]+\\s*=[^=\\n]+" - :tests ("const test: u32 = 1234;")) - - (:language "rust" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bstatic\\s+(mut\\s+)?JJJ:\\s*[^=\\n]+\\s*=[^=\\n]+" - :tests ("static test: u32 = 1234;" - "static mut test: u32 = 1234;")) - - ;; variable in method signature - (:language "rust" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bfn\\s+.+\\s*\\\((.+,\\s+)?JJJ:\\s*[^=\\n]+\\s*(,\\s*.+)*\\\)" - :tests ("fn abc(test: u32) -> u32 {" - "fn abc(x: u32, y: u32, test: Vec<u32>, z: Vec<Foo>)" - "fn abc(x: u32, y: u32, test: &mut Vec<u32>, z: Vec<Foo>)")) - - ;; "if let" and "while let" desugaring - (:language "rust" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(if|while)\\s+let\\s+([^=\\n]+)?(mut\\s+)?JJJ([^=\\n\\\(]+)?\\s*=\\s*[^=\\n]+" - :tests ("if let Some(test) = abc() {" - "if let Some(mut test) = abc() {" - "if let Ok(test) = abc() {" - "if let Ok(mut test) = abc() {" - "if let Foo(mut test) = foo {" - "if let test = abc() {" - "if let Some(test) = abc()" - "if let Some((a, test, b)) = abc()" - "while let Some(test) = abc() {" - "while let Some(mut test) = abc() {" - "while let Ok(test) = abc() {" - "while let Ok(mut test) = abc() {") - :not ("while let test(foo) = abc() {")) - - ;; structure fields - (:language "rust" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "struct\\s+[^\\n{]+[{][^}]*(\\s*JJJ\\s*:\\s*[^\\n},]+)[^}]*}" - :tests ("struct Foo { abc: u32, test: Vec<String>, b: PathBuf }" - "struct Foo<T>{test:Vec<T>}" - "struct FooBar<'a> { test: Vec<String> }") - :not ("struct Foo { abc: u32, b: Vec<String> }" - "/// ... construct the equivalent ...\nfn abc() {\n")) - - ;; enum variants - (:language "rust" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "enum\\s+[^\\n{]+\\s*[{][^}]*\\bJJJ\\b[^}]*}" - :tests ("enum Foo { VariantA, test, VariantB(u32) }" - "enum Foo<T> { test(T) }" - "enum BadStyle{test}" - "enum Foo32 { Bar, testing, test(u8) }") - :not ("enum Foo { testing }")) - - (:language "rust" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bfn\\s+JJJ\\s*\\\(" - :tests ("fn test(asdf: u32)" - "fn test()" - "pub fn test()")) - - (:language "rust" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bmacro_rules!\\s+JJJ" - :tests ("macro_rules! test")) - - (:language "rust" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "struct\\s+JJJ\\s*[{\\\(]?" - :tests ("struct test(u32, u32)" - "struct test;" - "struct test { abc: u32, def: Vec<String> }")) - - (:language "rust" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "trait\\s+JJJ\\s*[{]?" - :tests ("trait test;" "trait test { fn abc() -> u32; }")) - - (:language "rust" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\btype\\s+JJJ([^=\\n]+)?\\s*=[^=\\n]+;" - :tests ("type test<T> = Rc<RefCell<T>>;" - "type test = Arc<RwLock<Vec<u32>>>;")) - - (:language "rust" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "impl\\s+((\\w+::)*\\w+\\s+for\\s+)?(\\w+::)*JJJ\\s+[{]?" - :tests ("impl test {" - "impl abc::test {" - "impl std::io::Read for test {" - "impl std::io::Read for abc::test {")) - - (:language "rust" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "mod\\s+JJJ\\s*[{]?" - :tests ("mod test;" "pub mod test {")) - - ;; enum definitions - (:language "rust" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\benum\\s+JJJ\\b\\s*[{]?" - :tests ("enum test { A, B, C }" - "enum test {" - "pub enum test<T> {" - "pub enum test<T> { A, B }" - "pub enum test<T: Clone + Debug> {" - "enum test { Variant1, Variant2(Type) }" - "pub(crate) enum test { Variant }") - :not ("enum testing { A, B }" - "enum Foo { test, Bar }")) - - ;;-- elixir - (:language "elixir" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bdef(p)?\\s+JJJ\\s*[ ,\\\(]" - :tests ("def test do" - "def test, do:" - "def test() do" - "def test(), do:" - "def test(foo, bar) do" - "def test(foo, bar), do:" - "defp test do" - "defp test(), do:")) - - (:language "elixir" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*JJJ\\s*=[^=\\n]+" - :tests ("test = 1234") - :not ("if test == 1234")) - - (:language "elixir" :type "module" - :supports ("ag" "grep" "rg" "git-grep") - :regex "defmodule\\s+(\\w+\\.)*JJJ\\s+" - :tests ("defmodule test do" - "defmodule Foo.Bar.test do")) - - (:language "elixir" :type "module" - :supports ("ag" "grep" "rg" "git-grep") - :regex "defprotocol\\s+(\\w+\\.)*JJJ\\s+" - :tests ("defprotocol test do" - "defprotocol Foo.Bar.test do")) - - ;;-- erlang - (:language "erlang" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^JJJ\\b\\s*\\\(" - :tests ("test() ->" - "test()->" - "test(Foo) ->" - "test (Foo,Bar) ->" - "test(Foo, Bar)->")) - - (:language "erlang" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*JJJ\\s*=[^:=\\n]+" - :tests ("test = 1234") - :not ("if test =:= 1234" - "if test == 1234")) - - (:language "erlang" :type "module" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^-module\\\(JJJ\\\)" - :tests ("-module(test).")) - - ;;-- scss - (:language "scss" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "@mixin\\sJJJ\\b\\s*\\\(" - :tests ("@mixin test()")) - - (:language "scss" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "@function\\sJJJ\\b\\s*\\\(" - :tests ("@function test()")) - - (:language "scss" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "JJJ\\s*:\\s*" - :tests ("test :")) - - ;;-- sml - (:language "sml" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*(data)?type\\s+.*\\bJJJ\\b" - :tests ("datatype test =" - "datatype test=" - "datatype 'a test =" - "type test =" - "type 'a test =" - "type 'a test" - "type test") - :not ("datatypetest =")) - - (:language "sml" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*val\\s+\\bJJJ\\b" - :tests ("val test =" - "val test=" - "val test : bool")) - - (:language "sml" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*fun\\s+\\bJJJ\\b.*\\s*=" - :tests ("fun test list =" - "fun test (STRING_NIL, a) =" - "fun test ((s1,s2): 'a queue) : 'a * 'a queue =" - "fun test (var : q) : int =" - "fun test f e xs =")) - - (:language "sml" :type "module" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*(structure|signature|functor)\\s+\\bJJJ\\b" - :tests ("structure test =" - "structure test : MYTEST =" - "signature test =" - "functor test (T:TEST) =" - "functor test(T:TEST) =")) - - ;;-- sql - (:language "sql" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(CREATE|create)\\s+(.+?\\s+)?(FUNCTION|function|PROCEDURE|procedure)\\s+JJJ\\s*\\\(" - :tests ("CREATE FUNCTION test(i INT) RETURNS INT" - "create or replace function test (int)" - "CREATE PROCEDURE test (OUT p INT)" - "create definer = 'test'@'localhost' procedure test()")) - - (:language "sql" :type "table" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(CREATE|create)\\s+(.+?\\s+)?(TABLE|table)(\\s+(IF NOT EXISTS|if not exists))?\\s+JJJ\\b" - :tests ("CREATE TABLE test (" - "create temporary table if not exists test" - "CREATE TABLE IF NOT EXISTS test (" - "create global temporary table test")) - - (:language "sql" :type "view" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(CREATE|create)\\s+(.+?\\s+)?(VIEW|view)\\s+JJJ\\b" - :tests ("CREATE VIEW test (" - "create sql security definer view test" - "CREATE OR REPLACE VIEW test AS foo")) - - (:language "sql" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(CREATE|create)\\s+(.+?\\s+)?(TYPE|type)\\s+JJJ\\b" - :tests ("CREATE TYPE test" - "CREATE OR REPLACE TYPE test AS foo (" - "create type test as (")) - - ;;-- systemverilog - (:language "systemverilog" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*class\\s+\\bJJJ\\b" - :tests ("virtual class test;" - "class test;" - "class test extends some_class") - :not ("virtual class testing;" - "class test2;" - "class some_test" - "class some_class extends test")) - - (:language "systemverilog" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*task\\s+\\bJJJ\\b" - :tests ("task test (" - "task test(") - :not ("task testing (" - "task test2(")) - - (:language "systemverilog" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\b\\s*=" - :tests ("assign test =" - "assign test=" - "int test =" - "int test=") - :not ("assign testing =" - "assign test2=")) - - (:language "systemverilog" :type "function" : - supports ("ag" "rg" "git-grep") - :regex "function\\s[^\\s]+\\s*\\bJJJ\\b" - :tests ("function Matrix test ;" - "function Matrix test;") - :not ("function test blah")) - - ;; matches SV class handle declarations - (:language "systemverilog" :type "function" - :supports ("ag" "rg" "git-grep") - :regex "^\\s*[^\\s]*\\s*[^\\s]+\\s+\\bJJJ\\b" - :tests ("some_class_name test" - " another_class_name test ;" - "some_class test[];" - "some_class #(1) test") - :not ("test some_class_name" - "class some_class extends test")) - - ;;-- vhdl - (:language "vhdl" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*type\\s+\\bJJJ\\b" - :tests ("type test is" - "type test is") - :not ("type testing is" - "type test2 is")) - - (:language "vhdl" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*constant\\s+\\bJJJ\\b" - :tests ("constant test :" - "constant test:") - :not ("constant testing " - "constant test2:")) - - (:language "vhdl" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "function\\s*\"?JJJ\"?\\s*\\\(" - :tests ("function test(signal)" - "function test (signal)" - "function \"test\" (signal)") - :not ("function testing(signal")) - - ;;-- latex - (:language "tex" :type "command" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\\.*newcommand\\\*?\\s*\\\{\\s*(\\\\)JJJ\\s*}" - :tests ("\\newcommand{\\test}" - "\\renewcommand{\\test}" - "\\renewcommand*{\\test}" - "\\newcommand*{\\test}" - "\\renewcommand{ \\test }") - :not("\\test" "test")) - - (:language "tex" :type "command" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\\.*newcommand\\\*?\\s*(\\\\)JJJ\\j" - :tests ("\\newcommand\\test {}" - "\\renewcommand\\test{}" - "\\newcommand \\test") - :not("\\test" - "test")) - - (:language "tex" :type "length" : - supports ("ag" "grep" "rg" "git-grep") - :regex "\\\\(s)etlength\\s*\\\{\\s*(\\\\)JJJ\\s*}" - :tests ("\\setlength { \\test}" - "\\setlength{\\test}" - "\\setlength{\\test}{morecommands}" ) - :not("\\test" - "test")) - - (:language "tex" :type "counter" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\\newcounter\\\{\\s*JJJ\\s*}" - :tests ("\\newcounter{test}" ) - :not("\\test" - "test")) - - (:language "tex" :type "environment" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\\\.*newenvironment\\s*\\\{\\s*JJJ\\s*}" - :tests ("\\newenvironment{test}" - "\\newenvironment {test}{morecommands}" - "\\lstnewenvironment{test}" - "\\newenvironment {test}" ) - :not("\\test" - "test" )) - - ;;-- pascal (todo: var, type, const) - (:language "pascal" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bfunction\\s+JJJ\\b" - :tests (" function test : ")) - - (:language "pascal" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bprocedure\\s+JJJ\\b" - :tests (" procedure test ; ")) - - ;;-- f# - (:language "fsharp" :type "variable" - :supports ("ag" "rg" "grep" "git-grep") - :regex "let\\s+JJJ\\b.*\\\=" - :tests ("let test = 1234" - "let test() = 1234" - "let test abc def = 1234") - :not ("let testnot = 1234" - "let testnot() = 1234" - "let testnot abc def = 1234")) - - (:language "fsharp" :type "interface" - :supports ("ag" "rg" "grep" "git-grep") - :regex "member(\\b.+\\.|\\s+)JJJ\\b.*\\\=" - :tests ("member test = 1234" - "member this.test = 1234") - :not ("member testnot = 1234" - "member this.testnot = 1234")) - - (:language "fsharp" :type "type" - :supports ("ag" "rg" "grep" "git-grep") - :regex "type\\s+JJJ\\b.*\\\=" - :tests ("type test = 1234") - :not ("type testnot = 1234")) - - ;;-- kotlin - (:language "kotlin" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "fun\\s*(<[^>]*>)?\\s*JJJ\\s*\\(" - :tests ("fun test()" "fun <T> test()")) - - (:language "kotlin" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(val|var)\\s*JJJ\\b" - :not ("val testval" - "var testvar") - :tests ("val test " - "var test")) - - (:language "kotlin" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(class|interface)\\s*JJJ\\b" - :tests ("class test" - "class test : SomeInterface" - "interface test")) - - ;;-- zig - (:language "zig" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "fn\\s+JJJ\\b" - :tests ("fn test() void {" - "fn test(a: i32) i32 {" - "pub fn test(a: i32) i32 {" - "export fn test(a: i32) i32 {" - "extern \"c\" fn test(a: i32) i32 {" - "inline fn test(a: i32) i32 {")) - - (:language "zig" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(var|const)\\s+JJJ\\b" - :tests ("const test: i32 = 3;" - "var test: i32 = 3;" - "pub const test: i32 = 3;")) - - ;;-- protobuf - (:language "protobuf" :type "message" - :supports ("ag" "grep" "rg" "git-grep") - :regex "message\\s+JJJ\\s*\\\{" - :tests ("message test{" "message test {")) - - (:language "protobuf" :type "enum" - :supports ("ag" "grep" "rg" "git-grep") - :regex "enum\\s+JJJ\\s*\\\{" - :tests ("enum test{" "enum test {")) - - ;;-- apex (literally the same regexes as java) - (:language "apex" :type "function" - :supports ("ag" "rg") - :regex "^\\s*(?:[\\w\\[\\]]+\\s+){1,3}JJJ\\s*\\\(" - :tests ("int test()" - "int test(param)" - "static int test()" - "static int test(param)" - "public static MyType test()" - "private virtual SomeType test(param)" - "static int test()" - "private foo[] test()") - :not ("test()" "testnot()" - "blah = new test()" - "foo bar = test()")) - - (:language "apex" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*=[^=\\n)]+" :tests ("int test = 1234") - :not ("if test == 1234:" "int nottest = 44")) - - (:language "apex" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "(class|interface)\\s*JJJ\\b" - :tests ("class test:" - "public class test implements Something") - :not ("class testnot:" - "public class testnot implements Something")) - - ;;-- jai - (:language "jai" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*::" - :tests ("test ::")) - (:language "jai" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*(:|:\\s*=|::)" - :tests ("test: Type" "test : Type = Val" "test :: Val")) - (:language "jai" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*::" - :tests ("test ::")) - - ;;-- odin - (:language "odin" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\s*\\bJJJ\\s*:\\s*([^=\\n]+\\s*:|:|[^=\\n]+\\s*=|=)" - :tests ("test :: struct" - "test ::enum" - "test:: union" - "test: : custom_type" - "test :: [2]f32" - "test : f32 : 20" - "test: i32 : 10" - "test := 20" - "test : f32 = 20" - "test: i32 = 10" - "test: i32= 10" - "test :i32= 10" - "test :: proc()" - "test ::proc() {" - "test:: proc(a: i32) -> i32 {" - "test::proc{}" - "test: :proc \"contextless\" {}")) - - (:language "odin" :type "function" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*:\\s*:\\s*proc\\s*[({]" - :tests ("test :: proc(a: int)" - "test ::proc()" - "test:: proc(a: i32) -> i32 {" - "test::proc{}") - :not ("testnot :: proc()" - "test: proc()")) - - (:language "odin" :type "type" - :supports ("ag" "grep" "rg" "git-grep") - :regex "\\bJJJ\\s*:\\s*:\\s*(struct|enum|union|bit_set|bit_field)\\b" - :tests ("test :: struct {" - "test :: enum {" - "test :: union {" - "test :: bit_set {" - "test :: bit_field {") - :not ("testnot :: struct {" - "test :: structure_builder")) - - ;;-- cobol - (:language "cobol" :type "variable" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^(.{6}[^*/])?\\s*([frs]d|[[:digit:]]{1,2})\\s+JJJ([\\. ]|$)" - :tests (" 01 test." - "000350 10 test pic x." - " 88 test value '10'." - "fd test." - " sd test.") - :not (" *01 test" - " 05 test-01" - " 05 testing")) - - (:language "cobol" :type "section" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^(.{6}[^*/])?JJJ(\\s+section)?\\." - :tests (" test." - " test section." - "test." - "test section.") - :not (" test." - " *test section.")) - - (:language "cobol" :type "submodule" - :supports ("ag" "grep" "rg" "git-grep") - :regex "^(.{6}[^*/])?program-id\\.\\s*[\"']?JJJ[\"']?.*\\." - :tests (" program-id. test." - " program-id. 'test'." - "program-id. \"test\".") - :not (" test."))) - - "List of search regex pattern templates organized by language and type. -Used for generating the grep tool search commands. - -For a given language, a regular expression is only used by Dumb Jump when -the currently used search tool is identified in the :supports value. - -The regex string is a template filled by `dumb-jump-populate-regex' and -should contain the \"JJJ\" string, a marker for the searched identifier. - -It may also contain the following: - -- \"\\\\j\" : a marker for word-boundary regular-expression to use instead - of \"\\\\b\" when word boundary concept must support Lisp language - family and must not include the characters '-', '?' and '*'. - In the Lisp family of programming languages a large number of - characters are allowed in identifiers, including '-', '?' and - '*'. - This marker is replaced by value of the search tool specific - dumb-jump-TOOL-word-boundary, like `dumb-jump-ag-word-boundary' for - ag. - -- \"\\\\s\" : for a single white space character. - Replaced by \"[[:space:]]\" for some search tools as identified by - `dumb-jump-use-space-bracket-exp-for' returning t for a tool variant. - -The language types supported are listed in the linked page below: -- Ag: - URL \ `https://github.com/ggreer/the_silver_searcher/blob/master/tests/list_file_types.t' -- rg: - URL \ `https://github.com/BurntSushi/ripgrep/blob/master/crates/ignore/src/default_types.rs#L12' - -More information using the search tool command line help." - :group 'dumb-jump - :type - '(repeat - (plist :options ((:language string) - (:type string) - (:supports string) - (:regex string) - (:tests (repeat string)) - (:not (repeat string)))))) - -(defcustom dumb-jump-language-file-exts - ;; dumb-jump language file extension ag type rg type - '((:language "elisp" :ext "el" :agtype "elisp" :rgtype "elisp") - (:language "elisp" :ext "el.gz" :agtype "elisp" :rgtype "elisp") - (:language "commonlisp" :ext "lisp" :agtype "lisp" :rgtype "lisp") - (:language "commonlisp" :ext "lsp" :agtype "lisp" :rgtype "lisp") - (:language "c++" :ext "c" :agtype "cc" :rgtype "c") - (:language "c++" :ext "h" :agtype "cc" :rgtype "c") - (:language "c++" :ext "C" :agtype "cpp" :rgtype "cpp") - (:language "c++" :ext "H" :agtype "cpp" :rgtype "cpp") - (:language "c++" :ext "tpp" :agtype "cpp" :rgtype nil) - (:language "c++" :ext "cpp" :agtype "cpp" :rgtype "cpp") - (:language "c++" :ext "hpp" :agtype "cpp" :rgtype "cpp") - (:language "c++" :ext "cxx" :agtype "cpp" :rgtype "cpp") - (:language "c++" :ext "hxx" :agtype "cpp" :rgtype nil) - (:language "c++" :ext "cc" :agtype "cpp" :rgtype "cpp") - (:language "c++" :ext "hh" :agtype "cpp" :rgtype "cpp") - (:language "c++" :ext "c++" :agtype nil :rgtype nil) - (:language "c++" :ext "h++" :agtype nil :rgtype nil) - (:language "c++" :ext "ino" :agtype "cpp" :rgtype nil) - (:language "coq" :ext "v" :agtype nil :rgtype nil) - (:language "ocaml" :ext "ml" :agtype "ocaml" :rgtype "ocaml") - (:language "ocaml" :ext "mli" :agtype "ocaml" :rgtype "ocaml") - (:language "ocaml" :ext "mll" :agtype "ocaml" :rgtype "ocaml") - (:language "ocaml" :ext "mly" :agtype "ocaml" :rgtype "ocaml") - ;; groovy is nil type because jenkinsfile is not in searcher type lists - (:language "groovy" :ext "gradle" :agtype nil :rgtype nil) - (:language "groovy" :ext "groovy" :agtype nil :rgtype nil) - (:language "groovy" :ext "jenkinsfile" :agtype nil :rgtype nil) - (:language "haskell" :ext "hs" :agtype "haskell" :rgtype "haskell") - (:language "haskell" :ext "lhs" :agtype "haskell" :rgtype "haskell") - (:language "objc" :ext "m" :agtype "objc" :rgtype "objc") - (:language "csharp" :ext "cs" :agtype "csharp" :rgtype "csharp") - (:language "java" :ext "java" :agtype "java" :rgtype "java") - (:language "vala" :ext "vala" :agtype "vala" :rgtype "vala") - (:language "vala" :ext "vapi" :agtype "vala" :rgtype "vala") - (:language "julia" :ext "jl" :agtype "julia" :rgtype "julia") - (:language "clojure" :ext "clj" :agtype "clojure" :rgtype "clojure") - (:language "clojure" :ext "cljc" :agtype "clojure" :rgtype "clojure") - (:language "clojure" :ext "cljs" :agtype "clojure" :rgtype "clojure") - (:language "clojure" :ext "cljx" :agtype "clojure" :rgtype "clojure") - (:language "coffeescript" :ext "coffee" :agtype "coffee" :rgtype "coffeescript") - (:language "faust" :ext "dsp" :agtype nil :rgtype nil) - (:language "faust" :ext "lib" :agtype nil :rgtype nil) - (:language "fennel" :ext "fnl" :agtype nil :rgtype nil) - (:language "fortran" :ext "F" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "f" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "f77" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "f90" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "f95" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "F77" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "F90" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "F95" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "f03" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "for" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "ftn" :agtype "fortran" :rgtype "fortran") - (:language "fortran" :ext "fpp" :agtype "fortran" :rgtype "fortran") - (:language "go" :ext "go" :agtype "go" :rgtype "go") - (:language "javascript" :ext "js" :agtype "js" :rgtype "js") - (:language "javascript" :ext "jsx" :agtype "js" :rgtype "js") - (:language "javascript" :ext "vue" :agtype "js" :rgtype "js") - (:language "javascript" :ext "html" :agtype "html" :rgtype "html") - (:language "javascript" :ext "css" :agtype "css" :rgtype "css") - (:language "typescript" :ext "ts" :agtype "ts" :rgtype "ts") - (:language "typescript" :ext "tsx" :agtype "ts" :rgtype "ts") - (:language "typescript" :ext "vue" :agtype "ts" :rgtype "ts") - (:language "dart" :ext "dart" :agtype nil :rgtype "dart") - (:language "dlang" :ext "d" :agtype "dlang" :rgtype "d") - (:language "dlang" :ext "di" :agtype "dlang" :rgtype "d") - (:language "lua" :ext "lua" :agtype "lua" :rgtype "lua") - ;; the extension "m" is also used by obj-c so must use matlab-mode - ;; since obj-c will win by file extension, but here for searcher types - (:language "matlab" :ext "m" :agtype "matlab" :rgtype "matlab") - (:language "nim" :ext "nim" :agtype "nim" :rgtype "nim") - (:language "nix" :ext "nix" :agtype "nix" :rgtype "nix") - (:language "org" :ext "org" :agtype nil :rgtype "org") - (:language "perl" :ext "pl" :agtype "perl" :rgtype "perl") - (:language "perl" :ext "pm" :agtype "perl" :rgtype "perl") - (:language "perl" :ext "pm6" :agtype "perl" :rgtype nil) - (:language "perl" :ext "perl" :agtype nil :rgtype "perl") - (:language "perl" :ext "plh" :agtype nil :rgtype "perl") - (:language "perl" :ext "plx" :agtype nil :rgtype "perl") - (:language "perl" :ext "pod" :agtype "perl" :rgtype "pod") - (:language "perl" :ext "t" :agtype "perl" :rgtype nil) - (:language "php" :ext "php" :agtype "php" :rgtype "php") - (:language "php" :ext "php3" :agtype "php" :rgtype "php") - (:language "php" :ext "php4" :agtype "php" :rgtype "php") - (:language "php" :ext "php5" :agtype "php" :rgtype "php") - (:language "php" :ext "phtml" :agtype "php" :rgtype "php") - (:language "php" :ext "inc" :agtype "php" :rgtype nil) - (:language "purescript" :ext "purs" :agtype nil :rgtype nil) - (:language "python" :ext "py" :agtype "python" :rgtype "py") - (:language "r" :ext "R" :agtype "r" :rgtype "r") - (:language "r" :ext "r" :agtype "r" :rgtype "r") - (:language "r" :ext "Rmd" :agtype "r" :rgtype "r") - (:language "r" :ext "Rnw" :agtype "r" :rgtype "r") - (:language "r" :ext "Rtex" :agtype "r" :rgtype nil) - (:language "r" :ext "Rrst" :agtype "r" :rgtype nil) - (:language "racket" :ext "rkt" :agtype "racket" :rgtype "lisp") - (:language "crystal" :ext "cr" :agtype "crystal" :rgtype "crystal") - (:language "crystal" :ext "ecr" :agtype "crystal" :rgtype nil) - (:language "ruby" :ext "rb" :agtype "ruby" :rgtype "ruby") - (:language "ruby" :ext "erb" :agtype "ruby" :rgtype nil) - (:language "ruby" :ext "haml" :agtype "ruby" :rgtype nil) - (:language "ruby" :ext "rake" :agtype "ruby" :rgtype nil) - (:language "ruby" :ext "slim" :agtype "ruby" :rgtype nil) - (:language "rust" :ext "rs" :agtype "rust" :rgtype "rust") - (:language "zig" :ext "zig" :agtype nil :rgtype "zig") - (:language "scad" :ext "scad" :agtype nil :rgtype nil) - (:language "scala" :ext "scala" :agtype "scala" :rgtype "scala") - (:language "scheme" :ext "scm" :agtype "scheme" :rgtype "lisp") - (:language "scheme" :ext "ss" :agtype "scheme" :rgtype "lisp") - (:language "scheme" :ext "sld" :agtype "scheme" :rgtype "lisp") - (:language "janet" :ext "janet" :agtype "janet" :rgtype "lisp") - (:language "shell" :ext "sh" :agtype nil :rgtype nil) - (:language "shell" :ext "bash" :agtype nil :rgtype nil) - (:language "shell" :ext "csh" :agtype nil :rgtype nil) - (:language "shell" :ext "ksh" :agtype nil :rgtype nil) - (:language "shell" :ext "tcsh" :agtype nil :rgtype nil) - (:language "sml" :ext "sml" :agtype "sml" :rgtype "sml") - (:language "solidity" :ext "sol" :agtype nil :rgtype nil) - (:language "sql" :ext "sql" :agtype "sql" :rgtype "sql") - (:language "swift" :ext "swift" :agtype nil :rgtype "swift") - (:language "tex" :ext "tex" :agtype "tex" :rgtype "tex") - (:language "elixir" :ext "ex" :agtype "elixir" :rgtype "elixir") - (:language "elixir" :ext "exs" :agtype "elixir" :rgtype "elixir") - (:language "elixir" :ext "eex" :agtype "elixir" :rgtype "elixir") - (:language "erlang" :ext "erl" :agtype "erlang" :rgtype "erlang") - (:language "systemverilog" :ext "sv" :agtype "verilog" :rgtype "verilog") - (:language "systemverilog" :ext "svh" :agtype "verilog" :rgtype "verilog") - (:language "vhdl" :ext "vhd" :agtype "vhdl" :rgtype "vhdl") - (:language "vhdl" :ext "vhdl" :agtype "vhdl" :rgtype "vhdl") - (:language "scss" :ext "scss" :agtype "css" :rgtype "css") - (:language "pascal" :ext "pas" :agtype "delphi" :rgtype nil) - (:language "pascal" :ext "dpr" :agtype "delphi" :rgtype nil) - (:language "pascal" :ext "int" :agtype "delphi" :rgtype nil) - (:language "pascal" :ext "dfm" :agtype "delphi" :rgtype nil) - (:language "fsharp" :ext "fs" :agtype "fsharp" :rgtype nil) - (:language "fsharp" :ext "fsi" :agtype "fsharp" :rgtype nil) - (:language "fsharp" :ext "fsx" :agtype "fsharp" :rgtype nil) - (:language "kotlin" :ext "kt" :agtype "kotlin" :rgtype "kotlin") - (:language "kotlin" :ext "kts" :agtype "kotlin" :rgtype "kotlin") - (:language "protobuf" :ext "proto" :agtype "proto" :rgtype "protobuf") - (:language "hcl" :ext "tf" :agtype "terraform" :rgtype "tf") - (:language "hcl" :ext "tfvars" :agtype "terraform" :rgtype nil) - (:language "apex" :ext "cls" :agtype nil :rgtype nil) - (:language "apex" :ext "trigger" :agtype nil :rgtype nil) - (:language "jai" :ext "jai" :agtype nil :rgtype nil) - (:language "odin" :ext "odin" :agtype nil :rgtype nil) - (:language "cobol" :ext "cbl" :agtype nil :rgtype nil) - (:language "cobol" :ext "cob" :agtype nil :rgtype nil) - (:language "cobol" :ext "cpy" :agtype nil :rgtype nil)) - - "Map programming language to file extensions support by search tool. -The value of :agytpe, :rgtype is nil when the search tool file type does -not search for that file extension, otherwise it is the name of the file -type for that tool." - :group 'dumb-jump - :type - '(repeat - (plist - :options ((:language (string :tag "Language")) - (:ext (string :tag "Extension")) - (:agtype (string :tag "Ag type")) - (:rgtype (string :tag "Ripgrep type")))))) - -(defcustom dumb-jump-language-contexts - '((:language "javascript" :type "function" :left nil :right "^(" ) - (:language "javascript" :type "variable" :left "($" :right nil ) - (:language "javascript" :type "variable" :left "($" :right "^)" ) - (:language "javascript" :type "variable" :left nil :right "^\\." ) - (:language "javascript" :type "variable" :left nil :right "^;" ) - (:language "typescript" :type "function" :left nil :right "^(" ) - (:language "typescript" :type "type" :left "\\(?:[:<>,|&]\\|\\_<\\(?:as\\|extends\\|implements\\)\\_>\\)\\s-*$" :right nil) - (:language "typescript" :type "type" :left "\\_<\\(?:type\\|interface\\|enum\\|class\\)\\_>\\s-+$" :right nil) - (:language "perl" :type "function" :left nil :right "^(" ) - (:language "tcl" :type "function" :left "\\[$" :right nil) - (:language "tcl" :type "function" :left "^\\s*$" :right nil) - (:language "tcl" :type "variable" :left "\\$$" :right nil) - (:language "php" :type "function" :left nil :right "^(" ) - (:language "php" :type "class" :left "new\\s+" :right nil ) - (:language "elisp" :type "function" :left "($" :right nil ) - (:language "elisp" :type "variable" :left nil :right "^)" ) - (:language "scheme" :type "function" :left "($" :right nil ) - (:language "scheme" :type "variable" :left nil :right "^)" ) - (:language "jai" :type "function" :left nil :right "\\s*(" ) - (:language "jai" :type "type" :left "\\s*:\\s*" :right nil) - (:language "cobol" :type "submodule" :left "call\\s+" :right nil ) - (:language "cobol" :type "section" :left "perform\\s+" :right nil ) - (:language "cobol" :type "section" :left "go to\\s+" :right nil )) - "List of under points contexts for each language. -This helps limit the number of regular expressions we use -if we know that if there's a ( immediately to the right of -a symbol then it's probably a function call." - :group 'dumb-jump - :type - '(repeat - (plist - :options ((:language (string :tag "Language")) - (:type (choice (const "function") - (const "variable"))) - (:left (choice (const :tag "Anything" nil) - (string :tag "Regular expression"))) - (:right (choice (const :tag "Anything" nil) - (string :tag "Regular expression"))))))) - -(defcustom dumb-jump-project-denoters - '(".dumbjump" - ".projectile" - ".git" - ".hg" - ".fslckout" - ".bzr" - "_darcs" - ".svn" - "Makefile" - "PkgInfo" - "-pkg.el" - "_FOSSIL_" - "Cargo.toml") - "Files and directories that signify a directory is a project root. -If any of these denoting files are present in project sub-directories -(like Makefile) then you can either remove the culprit denoter from the -list or create a .dumbjumpignore file in the project sub-directory." - :group 'dumb-jump - :type '(repeat (string :tag "Name"))) - -(defcustom dumb-jump-default-project "~" - "Directory of default project to search within if a project root is not found." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-project nil - "Directory of project to search within if normal denoters will not work. -This should only be needed in the rarest of cases." - :group 'dumb-jump - :type 'string) - -(defcustom dumb-jump-rust-search-dependencies nil - "When non-nil, automatically include Rust dependency source paths. -Uses `cargo metadata' to discover crate source directories. -Requires `cargo' to be installed and a Cargo.toml in the project." - :group 'dumb-jump - :type 'boolean) - -(with-no-warnings ; don't warn about long example line - (defcustom dumb-jump-extra-search-paths-function nil - "Function to compute extra search paths for jump-to-definition lookups. -When non-nil, this function is called with two arguments: LANG (a -string naming the programming language, or nil if undetected) and -PROJ-ROOT (the project root directory). It should return a list of -directory path strings to include in the search, or nil. - -Returned paths may be absolute or relative to PROJ-ROOT (relative -entries are expanded via `expand-file-name'). Non-existent -directories and non-string entries are silently ignored. - -This is useful for dynamically adding paths such as virtualenv -site-packages, installed library sources, or SDK directories. - -Example: - - (setq dumb-jump-extra-search-paths-function - (lambda (lang proj-root) - (when (string= lang \"python\") - (let* ((default-directory proj-root) - (path (string-trim - (shell-command-to-string - \"poetry run python -c \\\"import site; print(site.getsitepackages()[0])\\\"\")))) - (when (file-directory-p path) - (list path))))))" - :group 'dumb-jump - :type '(choice (const :tag "None" nil) - function))) - -(defcustom dumb-jump-before-jump-hook nil - "Hooks called before jumping." - :group 'dumb-jump - :type 'hook) - -(defcustom dumb-jump-after-jump-hook nil - "Hooks called after jumping." - :group 'dumb-jump - :type 'hook) - -(defcustom dumb-jump-aggressive - nil - "If `t` jump aggressively with the possibility of a false positive. -If `nil` always show list of more than 1 match." - :group 'dumb-jump - :type 'boolean) - -(defcustom dumb-jump-debug - nil - "If `t` will print helpful debug information. -Also ensure that `dumb-jump-quiet' is nil for debugging!" - :group 'dumb-jump - :type 'boolean) - -(defcustom dumb-jump-confirm-jump-to-modified-file - t - "Confirm before jumping to a modified file? -If t, confirm before jumping to a modified file (which may lead to an -inaccurate jump). -If nil, jump without confirmation but print a warning." - :group 'dumb-jump - :type 'boolean) - -(defcustom dumb-jump-disable-obsolete-warnings nil - "If non-nil, don't warn about using the legacy interface." - :group 'dumb-jump - :type 'boolean) - -;; --------------------------------------------------------------------------- -;; Debugging Utilities -;; ------------------- - -(defun dumb-jump-message-prin1 (format-str &rest args) - "Helper debugging function: generate a FORMAT-STR message with all ARGS." - ;; Fist transform each of ARGS to string with `prin1-to-string' then - ;; pass them as arguments to message by making a list used the third - ;; parameter to apply. - (apply 'message format-str (mapcar #'prin1-to-string args))) - -;; --------------------------------------------------------------------------- -;; Search tool presence checkers -;; ----------------------------- -(defvar dumb-jump--detected-env-problems nil - "List of detected environment problems. -Last detected problem is first in the list.") - -(defun dumb-jump-env-problem (problem) - "Add PROBLEM string to `dumb-jump--detected-env-problems' list." - (unless (member problem dumb-jump--detected-env-problems) - (push problem dumb-jump--detected-env-problems))) - -;;;###autoload -(defun dumb-jump-show-detected-problems (keep) - "Print all problems detected by dumb-jump environment in *Message*. -Erase the accumulated list unless the command is issued with any prefix -key (such as `\\[universal-argument]')." - (interactive "P") - (if dumb-jump--detected-env-problems - (progn - (message "-- Dumb-Jump Detected Environment Problems:") - (dolist (problem (reverse dumb-jump--detected-env-problems)) - (message problem)) - (unless keep - (setq dumb-jump--detected-env-problems nil))) - (message "No problem recorded yet."))) - -;; -- - -(defvar dumb-jump--ag-installed? 'unset) -(defun dumb-jump-ag-installed? () - "Return t if ag is installed." - (if (eq dumb-jump--ag-installed? 'unset) - (setq dumb-jump--ag-installed? - (dumb-jump--contains-p "ag version" - (shell-command-to-string - (concat dumb-jump-ag-cmd " --version")))) - dumb-jump--ag-installed?)) - -(defvar dumb-jump--git-grep-plus-ag-installed? 'unset) -(defun dumb-jump-git-grep-plus-ag-installed? () - "Return t if git grep and ag is installed." - (if (eq dumb-jump--git-grep-plus-ag-installed? 'unset) - (setq dumb-jump--git-grep-plus-ag-installed? - (and (dumb-jump-git-grep-installed?) - (dumb-jump-ag-installed?))) - dumb-jump--git-grep-plus-ag-installed?)) - -(defvar dumb-jump--rg-installed? 'unset) -(defun dumb-jump-rg-installed? () - "Return t if rg 0.10 or later with PCRE2 support is installed. -Return nil otherwise. In that case store diagnostics information in the -variable `dumb-jump--detected-env-problems'." - (if (eq dumb-jump--rg-installed? 'unset) - (setq - dumb-jump--rg-installed? - (catch 'rg-problem - (unless (executable-find dumb-jump-rg-cmd) - (dumb-jump-env-problem - (format "Ripgrep not found as specified in `dumb-jump-rg-cmd': %s" - dumb-jump-rg-cmd)) - (throw 'rg-problem nil)) - (let* ((stdout (shell-command-to-string - (concat dumb-jump-rg-cmd " --version"))) - (has-version (string-match "ripgrep \\([0-9]+\\.[0-9]+\\).*" - stdout))) - (unless has-version - (dumb-jump-env-problem "Can't detect Ripgrep version.") - (throw 'rg-problem nil)) - (unless (version<= "0.10" (match-string-no-properties 1 stdout)) - (dumb-jump-env-problem "Ripgrep >= 0.10 is not available.") - (throw 'rg-problem nil)) - (unless (string-match "features:.*pcre2" stdout) - (dumb-jump-env-problem "Ripgrep does not support PCRE2.") - (throw 'rg-problem nil)) - t))) - dumb-jump--rg-installed?)) - -(defvar dumb-jump--git-grep-installed? 'unset) -(defun dumb-jump-git-grep-installed? () - "Return t if git-grep is installed." - (if (eq dumb-jump--git-grep-installed? 'unset) - (setq dumb-jump--git-grep-installed? - (dumb-jump--contains-p "fatal: no pattern given" - (shell-command-to-string - (concat dumb-jump-git-grep-cmd)))) - dumb-jump--git-grep-installed?)) - -(defvar dumb-jump--grep-installed? 'unset) -(defun dumb-jump-grep-installed? () - "Return non-nil if a grep is installed, nil otherwise. -Return \\='gnu if GNU grep is installed, \\='bsd if BSD grep is installed." - (if (eq dumb-jump--grep-installed? 'unset) - (let* ((version (shell-command-to-string - (concat dumb-jump-grep-cmd " --version"))) - (variant (cond ((dumb-jump--match "GNU grep" version) 'gnu) - ((dumb-jump--match "[0-9]+\\.[0-9]+" version) 'bsd) - (t nil)))) - (setq dumb-jump--grep-installed? variant)) - dumb-jump--grep-installed?)) - -;; --------------------------------------------------------------------------- -;; Dumb-Jump Tests -;; --------------- - -(defun dumb-jump-run-test (test cmd) - "Use TEST as the standard input for the CMD." - (with-temp-buffer - (insert test) - (shell-command-on-region (point-min) (point-max) cmd nil t) - (buffer-substring-no-properties (point-min) (point-max)))) - -(defun dumb-jump-run-test-temp-file (test thefile realcmd) - "Write TEST string to temporary file THEFILE, run shell REALCMD on it. -Return resulting string." - (with-temp-buffer - (insert test) - (write-file thefile nil) - (delete-region (point-min) (point-max)) - (shell-command realcmd t) - (set-buffer-modified-p nil) ; prevent prompt on file deletion during test - (delete-file thefile) - (buffer-substring-no-properties (point-min) (point-max)))) - -(defun dumb-jump-run-git-grep-test (test git-grep-cmd) - "Execute GIT-GREP-CMD on input TEST string written in temporary file. -Necessary because git grep must be given a file as input, not just a string." - (let ((thefile ".git.grep.test")) - (dumb-jump-run-test-temp-file test - thefile - (concat git-grep-cmd " " thefile)))) - -(defun dumb-jump-run-ag-test (test ag-cmd) - "Execute AG-CMD on input TEST written in temporary file. -The difference is that ag ignores multiline matches when passed -input from stdin, which is a crucial feature." - (let ((thefile ".ag.test")) - (dumb-jump-run-test-temp-file test - thefile - (concat ag-cmd " " thefile)))) - -;; --------------------------------------------------------------------------- -;; Test dumb-jump search rules -;; --------------------------- - -(defun dumb-jump--search-failure-msg (tool test run-not-tests resp cmd rule) - "Return search failure string adjusted to the arguments. -TOOL: search tool name. -TEST: the test string. -RUN-NO-TESTS: t to see a list of all failed rules. -RESP: response. -CMD: the search command used. -RULE: the complete `dumb-jump-find-rules' rule used for this test." - (format "%s FAILURE '%s' %s in response '%s' | CMD: '%s' | rule: '%s'" - tool - test - (if run-not-tests "IS unexpectedly" "NOT") - resp - cmd - rule)) - -(defun dumb-jump-test-grep-rules (&optional run-not-tests) - "Test all the grep rules and return count of those that fail. -Optionally pass t for RUN-NOT-TESTS to see a list of all failed rules." - (let ((variant (if (eq (dumb-jump-grep-installed?) 'gnu) 'gnu-grep 'grep))) - (mapcan - (lambda (rule) - (mapcan - (lambda (test) - (let* ((cmd (concat "grep -En -e " - (shell-quote-argument - (dumb-jump-populate-regex - (plist-get rule :regex) "test" variant)))) - (resp (dumb-jump-run-test test cmd))) - (when (or - (and (not run-not-tests) (not (dumb-jump--contains-p test resp))) - (and run-not-tests (> (length resp) 0))) - (list (dumb-jump--search-failure-msg "grep" - test - run-not-tests - resp - cmd - (plist-get rule :regex)))))) - (plist-get rule (if run-not-tests :not :tests)))) - (seq-filter (lambda (it) (member "grep" (plist-get it :supports))) dumb-jump-find-rules)))) - -(defun dumb-jump-test-ag-rules (&optional run-not-tests) - "Test all the ag rules and return count of those that fail. -Optionally pass t for RUN-NOT-TESTS to see a list of all failed rules." - (mapcan - (lambda (rule) - (mapcan - (lambda (test) - (let* ((cmd (concat "ag --nocolor --nogroup --nonumber " - (shell-quote-argument - (dumb-jump-populate-regex - (plist-get rule :regex) "test" 'ag)))) - (resp (dumb-jump-run-ag-test test cmd))) - (when (or - (and (not run-not-tests) (not (dumb-jump--contains-p test resp))) - (and run-not-tests (> (length resp) 0))) - (list (dumb-jump--search-failure-msg "ag" - test - run-not-tests - resp - cmd - rule))))) - (plist-get rule (if run-not-tests :not :tests)))) - (seq-filter (lambda (it) (member "ag" (plist-get it :supports))) dumb-jump-find-rules))) - -(defun dumb-jump-test-rg-rules (&optional run-not-tests) - "Test all the rg rules and return count of those that fail. -Optionally pass t for RUN-NOT-TESTS to see a list of all failed rules." - (mapcan - (lambda (rule) - (mapcan - (lambda (test) - (let* ((cmd (concat "rg --color never --no-heading -U --pcre2 " - (shell-quote-argument - (dumb-jump-populate-regex - (plist-get rule :regex) "test" 'rg)))) - (resp (dumb-jump-run-test test cmd))) - (when (or - (and (not run-not-tests) (not (dumb-jump--contains-p test resp))) - (and run-not-tests (> (length resp) 0))) - (list (dumb-jump--search-failure-msg "rg" - test - run-not-tests - resp - cmd - rule))))) - (plist-get rule (if run-not-tests :not :tests)))) - (seq-filter (lambda (it) (member "rg" (plist-get it :supports))) dumb-jump-find-rules))) - -(defun dumb-jump-test-git-grep-rules (&optional run-not-tests) - "Test all the git grep rules and return count of those that fail. -Optionally pass t for RUN-NOT-TESTS to see a list of all failed rules. - -Note: Tests rules that support \"grep\" since git-grep uses the same -ERE syntax. Testing actual git-grep would require temp git repos." - (mapcan - (lambda (rule) - (mapcan - (lambda (test) - (let* ((cmd (concat "git grep --color=never -h --untracked -E " - (shell-quote-argument - (dumb-jump-populate-regex - (plist-get rule :regex) "test" 'git-grep)))) - (resp (dumb-jump-run-git-grep-test test cmd))) - (when (or - (and (not run-not-tests) (not (dumb-jump--contains-p test resp))) - (and run-not-tests (> (length resp) 0))) - (list (dumb-jump--search-failure-msg "git-grep" - test - run-not-tests - resp - cmd - rule))))) - (plist-get rule (if run-not-tests :not :tests)))) - (seq-filter (lambda (it) (member "grep" (plist-get it :supports))) dumb-jump-find-rules))) - -;; --------------------------------------------------------------------------- - -(defun dumb-jump-message (str &rest args) - "Log message STR with ARGS to *Messages* if not using `dumb-jump-quiet'." - (unless dumb-jump-quiet - (apply 'message str args)) - nil) - -(defmacro dumb-jump-debug-message (&rest exprs) - "Generate a debug message to print all expressions EXPRS." - (declare (indent defun)) - (let ((i 5) frames frame) - ;; based on https://emacs.stackexchange.com/a/2312 - (while (setq frame (backtrace-frame i)) - (push frame frames) - (cl-incf i)) - ;; this is a macro-expanded version of the code in the stackexchange - ;; code from above. This version should work on emacs-24.3, since it - ;; doesn't depend on thread-last. - (let* ((frame (cl-find-if - (lambda (frame) - (ignore-errors - (and (car frame) - (eq (caaddr frame) - 'defalias)))) - (reverse frames))) - (func (cl-cadadr (cl-caddr frame))) - (defun-name (symbol-name func))) - (with-temp-buffer - (insert "DUMB JUMP DEBUG `") - (insert defun-name) - (insert "` START\n----\n\n") - (dolist (expr exprs) - (insert (prin1-to-string expr) ":\n\t%s\n\n")) - (insert "\n-----\nDUMB JUMP DEBUG `") - (insert defun-name) - (insert "` END\n-----") - `(when dumb-jump-debug - (dumb-jump-message - ,(buffer-string) - ,@exprs)))))) - -(defun dumb-jump-get-point-context (line func cur-pos) - "Get the LINE context to the left and right of FUNC using CUR-POS as hint." - (let ((loc (or (cl-search func line :start2 cur-pos) 0))) - (list :left (substring line 0 loc) - :right (substring line (+ loc (length func)))))) - -(defun dumb-jump-to-selected (results choices selected) - "With RESULTS use CHOICES to find the SELECTED choice from multiple options." - (let* ((result-index (dumb-jump--find-index (lambda (it) (string= selected it)) choices)) - (result (when result-index - (nth result-index results)))) - (when result - (dumb-jump-result-follow result)))) - -(defun dumb-jump-helm-persist-action (candidate) - "Preview CANDIDATE in temporary buffer displaying the file at matched line. -\\<helm-map> -This is the persistent action (\\[helm-execute-persistent-action]) for helm." - (let* ((file (plist-get candidate :path)) - (line (plist-get candidate :line)) - (default-directory-old default-directory)) - (switch-to-buffer (get-buffer-create " *helm dumb jump persistent*")) - (setq default-directory default-directory-old) - (fundamental-mode) - (erase-buffer) - (insert-file-contents file) - (let ((buffer-file-name file)) - (set-auto-mode) - (font-lock-fontify-region (point-min) (point-max)) - (goto-char (point-min)) - (forward-line (1- line))))) - -(defun dumb-jump--format-result (proj-root result) - "Return file:line:target formatted RESULT as a string stripped of PROJ-ROOT." - (format "%s:%s: %s" - (dumb-jump--replace proj-root "" (plist-get result :path)) - (plist-get result :line) - (dumb-jump--trim (plist-get result :context)))) - -(defun dumb-jump-ivy-jump-to-selected (results choices _proj) - "Offer CHOICES as candidates through `ivy-read'. -Then execute dumb-jump-result-follow' on the selected choice RESULTS. -Ignore _PROJ." - (if (fboundp 'ivy-read) - (ivy-read "Jump to: " (dumb-jump--zip-pair choices results) - :action (lambda (cand) - (dumb-jump-result-follow (cdr cand))) - :caller 'dumb-jump-ivy-jump-to-selected) - (error "ivy-read is unknown. Is it loaded?"))) - -(defun dumb-jump-prompt-user-for-choice (proj-root results) - "Prompt user to select one of the identified RESULTS in PROJ-ROOT. -Strip the PROJ-ROOT (project root path) from the file name shown in each entry. -Prompt with the mechanism selected by `dumb-jump-selector' user-option if -available otherwise default to `completing-read'." - (let ((choices (mapcar (lambda (it) (dumb-jump--format-result proj-root it)) results))) - (cond - ((eq dumb-jump-selector 'completing-read) - (dumb-jump-to-selected results choices - (dumb-jump--select-choice choices "Jump to: "))) - ;; - ((and (eq dumb-jump-selector 'ivy) - (fboundp 'ivy-read)) - (funcall dumb-jump-ivy-jump-to-selected-function - results choices proj-root)) - ;; - ((and (eq dumb-jump-selector 'helm) - (fboundp 'helm)) - (helm :sources - (with-no-warnings - (helm-make-source "Jump to: " 'helm-source-sync - :action '(("Jump to match" . dumb-jump-result-follow)) - :candidates (dumb-jump--zip-pair choices results) - :persistent-action 'dumb-jump-helm-persist-action)) - :buffer "*helm dumb jump choices*")) - ;; fallback for unsupported selector values - (t (dumb-jump-to-selected results choices - (dumb-jump--select-choice choices "Jump to: ")))))) - -(defun dumb-jump-get-project-root (filepath) - "Return project root holding FILEPATH. -Keep looking at the parent dir of FILEPATH until a denoter file/dir is found. -Fall back to `project.el' when available and no denoter is found. -Return a directory name without the trailing slash." - (let* ((path (expand-file-name filepath)) - (dir (if (file-directory-p path) - (file-name-as-directory path) - (file-name-directory path))) - (project-el-root - (when (and (null dumb-jump-project) - dir - (fboundp 'project-current)) - (let ((default-directory dir)) - (let ((proj (ignore-errors (project-current nil)))) - (when proj - (if (fboundp 'project-root) - (project-root proj) - (with-no-warnings - ;; On Emacs 26.1 use now obsolete `project-roots' - (car (project-roots proj)))))))))) - (directory-file-name - (expand-file-name - (or dumb-jump-project - (locate-dominating-file path #'dumb-jump-get-config) - project-el-root - dumb-jump-default-project))))) - -(defvar dumb-jump--rust-deps-cache (make-hash-table :test 'equal) - "Cache of Rust dependency paths keyed by project root.") - -(defun dumb-jump-get-rust-dependency-paths (proj-root) - "Return list of source directories for Rust dependencies in PROJ-ROOT. -Uses `cargo metadata' to discover dependency crate source paths. -Results are cached per project root." - (let ((cached (gethash proj-root dumb-jump--rust-deps-cache 'dumb-jump--no-cache))) - (if (not (eq cached 'dumb-jump--no-cache)) - cached - (let ((dep-paths - (when (file-exists-p (expand-file-name "Cargo.toml" proj-root)) - (let* ((default-directory proj-root) - (json-output (with-temp-buffer - (let ((exit-code (call-process "cargo" nil t nil - "metadata" "--format-version=1"))) - (when (eq exit-code 0) - (buffer-string))))) - (json-data (ignore-errors (when json-output (json-read-from-string json-output)))) - (packages (when json-data (cdr (assoc 'packages json-data)))) - (paths (when packages - (seq-uniq - (seq-filter - #'file-directory-p - (mapcar (lambda (pkg) - (file-name-directory - (cdr (assoc 'manifest_path pkg)))) - packages)))))) - (seq-remove - (lambda (p) (string= (directory-file-name p) - (directory-file-name proj-root))) - paths))))) - (puthash proj-root dep-paths dumb-jump--rust-deps-cache) - dep-paths)))) - -(defun dumb-jump-get-config (dir) - "If a project denoter is in DIR then return it, otherwise nil. -However, if DIR contains a `.dumbjumpignore' it returns nil to keep -looking for another root." - (if (file-exists-p (expand-file-name ".dumbjumpignore" dir)) - nil - (car (seq-filter - (lambda (it) (file-exists-p (expand-file-name it dir))) - dumb-jump-project-denoters)))) - -(defun dumb-jump-get-language (file) - "Get language from FILE extension. Fallback to using `major-mode' name." - (let* ((language (or (dumb-jump-get-language-from-mode) - (dumb-jump-get-language-by-filename file) - (dumb-jump-get-mode-base-name)))) - ; src edit buffer ? org-edit-src-exit - (if (and (fboundp 'org-src-edit-buffer-p) - (org-src-edit-buffer-p)) - (progn - (setq language "org") - (with-no-warnings - (org-edit-src-exit)) - (if (and (boundp 'org-version) - (version< org-version "9")) - (save-buffer)))) - (if (string= language "org") - (setq language (dumb-jump-get-language-in-org))) - (if (member language (seq-uniq - (mapcar (lambda (it) (plist-get it :language)) - dumb-jump-find-rules))) - language - (format ".%s file" (or (file-name-extension file) ""))))) - -(defun dumb-jump-get-language-in-org () - "Return associated language in org mode src block or \"org\" if outside src. -This assumes point is inside an org mode buffer." - (let ((lang (nth 0 (with-no-warnings (org-babel-get-src-block-info))))) - ;; if lang exists then create a composite language - (if lang - (dumb-jump-make-composite-language - "org" - (if (dumb-jump-get-language-from-aliases lang) - (dumb-jump-get-language-from-aliases lang) - lang) - "org" - "org" - "org") - "org"))) - -(defun dumb-jump-add-language-to-proplist (newlang proplist lang) - "Return nil if NEWLANG is already in PROPLIST or (if not) -return a new proplist. The new proplis is PROPLIS -where a NEWLANG plist(s) is (are) added to PROPLIST. -The plist(s) value of NEWLANG is (are) copied from -those of LANG and LANG is replaced by NEWLANG." - (unless (seq-filter (lambda (it) (string= newlang (plist-get it :language))) - proplist) - (dumb-jump--splice - (lambda (it) (string= lang (plist-get it :language))) - (lambda (it) (list it (plist-put (copy-tree it) :language newlang))) - proplist))) - -(defun dumb-jump-make-composite-language (mode lang extension agtype rgtype) - "Concat one MODE (usually the string org) with a LANG (c or python or etc) -to make a composite language of the form cPLUSorg or pythonPLUSorg or etc. -Modify `dumb-jump-find-rules' and `dumb-jump-language-file-exts' accordingly -\(using EXTENSION AGTYPE RGTYPE)" - (let* ((complang (concat lang "PLUS" mode)) - (alreadyextension (seq-filter (lambda (it) - (and - (string= complang (plist-get it :language)) - (string= extension (plist-get it :ext)) - (string= agtype (plist-get it :agtype)) - (string= rgtype (plist-get it :rgtype)))) - dumb-jump-language-file-exts)) - (newfindrule (dumb-jump-add-language-to-proplist complang dumb-jump-find-rules lang)) - (newfileexts (dumb-jump-add-language-to-proplist complang dumb-jump-language-file-exts lang))) - (when newfindrule - (set-default 'dumb-jump-find-rules newfindrule)) - (unless dumb-jump-search-type-org-only-org - (when newfileexts - (set-default 'dumb-jump-language-file-exts newfileexts))) - (unless alreadyextension - (set-default 'dumb-jump-language-file-exts - (cons `(:language ,complang - :ext ,extension - :agtype ,agtype - :rgtype ,rgtype) - dumb-jump-language-file-exts))) - complang)) - -(defcustom dumb-jump-language-aliases-alist - '(("sh" . "shell") - ("d" . "dlang") - ("cperl" . "perl") - ("octave" . "matlab") - ("emacs-lisp" . "elisp") - ("R" . "r") - ("arduino" . "c++")) - "An alist of language alias to language name. -Aliases are major mode base name sometimes used for some files. -For example: \"cperl\" for the \"perl\" language." - :group 'dumb-jump - :type '(repeat (cons - (string :tag "alias ") - (string :tag "language")))) - -(defun dumb-jump-get-language-from-aliases (lang) - "Return the dumb-jump language name for a possible alias if there is one. -Return nil if LANG is not one of the supported aliases." - (assoc-default lang dumb-jump-language-aliases-alist)) - -(defun dumb-jump-get-mode-base-name () - "Get the base name of the mode." - (dumb-jump--replace "-mode" "" (symbol-name major-mode))) - -(defun dumb-jump-get-language-from-mode () - "Extract the language from the `major-mode' name. -Currently just everything before \"-mode\"." - (dumb-jump-get-language-from-aliases (dumb-jump-get-mode-base-name))) - -(defun dumb-jump-get-language-by-filename (file) - "Get the programming language name from the specified FILE extension." - ;; Search in `dumb-jump-language-file-exts' for an entry that has the :ext - ;; attribute equal to the file extension and return the corresponding - ;; :language value. - (let* ((filename (if (string-suffix-p ".gz" file) - (file-name-sans-extension file) - file)) - (result (seq-filter - (lambda (it) (string-suffix-p (concat "." (plist-get it :ext)) filename)) - dumb-jump-language-file-exts))) - (when (and result (eq (length result) 1)) - (plist-get (car result) :language)))) - -;; -- - -(defun dumb-jump-issue-result (issue) - "Return a result property list with the ISSUE set as :issue property symbol." - `(:results nil - :lang nil - :symbol nil - :ctx-type nil - :file nil - :root nil - :issue ,(intern issue))) - -(defun dumb-jump-get-results (&optional entered-name) - "Perform the dumb-jump search for text at point, region or ENTERED-NAME. - -Runs `dumb-jump-fetch-results' under conditions adjusted to the current -context. - -Perform the search if searcher is installed, buffer is saved, and -there's a symbol under point or an item to search is specified by the -ENTERED-NAME string. - -Return the dumb-jump alist result: -- :results -- :lang : string: language name -- :symbol : string: symbol being searched -- :ctx-type: string: -- :file : string: file name -- :root : string: project root -- :issue : symbol: problem description symbol: nogrep or nosymbol." - ;; Prevent a empty string entered-name from being interpreted as user entry - ;; because `read-from-minibuffer' may return "". - (when (and entered-name (string-blank-p entered-name)) - (setq entered-name nil)) - (cond - ;; When no search tool is available just return an empty result identifying - ;; a nogrep issue. - ((not (or (dumb-jump-ag-installed?) - (dumb-jump-rg-installed?) - (dumb-jump-git-grep-installed?) - (dumb-jump-grep-installed?))) - (dumb-jump-issue-result "nogrep")) - ;; Inside a shell or eshell buffer, - ((derived-mode-p 'shell-mode 'eshell-mode) - (dumb-jump-fetch-shell-results entered-name)) - ;; When inside a normal buffer but no string specified by ENTERED-NAME, - ;; point or region does not identify something to search, - ;; just return an empty result identifying a nosymbol issue. - ((and (not entered-name) - (not (region-active-p)) - (not (thing-at-point 'symbol))) - (dumb-jump-issue-result "nosymbol")) - ;; Otherwise, perform the search for the text identified by string specified - ;; by ENTERED-NAME, point or region. - (t - (dumb-jump-fetch-file-results entered-name)))) - -(defun dumb-jump-fetch-shell-results (&optional entered-name) - "Perform search from shell buffer for text at point, region or ENTERED-NAME. -Return the dumb-jump alist result: -- :results -- :lang : string: language name -- :symbol : string: symbol being searched -- :ctx-type: string: -- :file : string: file name -- :root : string: project root." - (let* ((cur-file (buffer-name)) - (proj-root (dumb-jump-get-project-root default-directory)) - (proj-config (dumb-jump-get-config proj-root)) - (config (when (string-suffix-p ".dumbjump" proj-config) - (dumb-jump-read-config proj-root proj-config))) - (lang (or (plist-get config :language) - (car (dumb-jump-get-lang-by-shell-contents (buffer-name)))))) - (dumb-jump-fetch-results cur-file proj-root lang config entered-name))) - -(defun dumb-jump-fetch-file-results (&optional entered-name) - "Perform a file search for text at point, region or ENTERED-NAME string. -Return the dumb-jump alist result: -- :results -- :lang : string: language name -- :symbol : string: symbol being searched -- :ctx-type: string: -- :file : string: file name -- :root : string: project root." - (let* ((cur-file (or (buffer-file-name) "")) - (proj-root (dumb-jump-get-project-root cur-file)) - (proj-config (dumb-jump-get-config proj-root)) - (config (when (string-suffix-p ".dumbjump" proj-config) - (dumb-jump-read-config proj-root proj-config))) - (lang (or (plist-get config :language) - (dumb-jump-get-language cur-file)))) - (dumb-jump-fetch-results cur-file proj-root lang config entered-name))) - -;; -- -(defun dumb-jump-process-symbol-by-lang (lang look-for) - "Process and potentially transform LANG's LOOK-FOR. -For instance, remove clojure namespace prefix." - (cond - ((and (string= lang "commonlisp") - (dumb-jump--contains-p ":" look-for) - (not (string-prefix-p ":" look-for))) - (nth 1 (dumb-jump--split ":" look-for 'omit-nulls))) - ((and (string= lang "clojure") - (dumb-jump--contains-p "/" look-for)) - (nth 1 (dumb-jump--split "/" look-for))) - ((and (string= lang "fennel") - (dumb-jump--contains-p "." look-for)) - (car (last (dumb-jump--split "\\." look-for)))) - ((and (string= lang "ruby") - (dumb-jump--contains-p "::" look-for)) - (car (last (dumb-jump--split "::" look-for)))) - ((and (or (string= lang "ruby") - (string= lang "crystal")) - (string-prefix-p ":" look-for)) - (dumb-jump--chop-prefix ":" look-for)) - ((and (string= lang "systemverilog") - (string-prefix-p "`" look-for)) - (dumb-jump--chop-prefix "`" look-for)) - (t - look-for))) - -(defun dumb-jump-get-point-line () - "Get line at point." - (thing-at-point 'line t)) - -(defun dumb-jump-get-point-symbol () - "Get symbol at point." - (if (region-active-p) - (buffer-substring-no-properties (region-beginning) (region-end)) - (thing-at-point 'symbol t))) - -(defun dumb-jump--get-symbol-start () - "Get the start of symbol at point." - (- (if (region-active-p) - (region-beginning) - (car (bounds-of-thing-at-point 'symbol))) - (line-beginning-position))) - -(defun dumb-jump-get-lang-by-shell-contents (buffer) - "Return languages in BUFFER by checking if file extension is mentioned." - (let* ((buffer-contents (with-current-buffer buffer - (buffer-string))) - (found (seq-filter (lambda (it) - (dumb-jump--match (concat "\\." (regexp-quote (plist-get it :ext)) "\\b") - buffer-contents)) - dumb-jump-language-file-exts))) - (mapcar (lambda (it) (plist-get it :language)) found))) - -(defun dumb-jump-fetch-results (cur-file proj-root lang config - &optional entered-name) - "Search for symbol in ENTERED-NAME or symbol at point. - -Return a list of results based on current file context and calling the -currently selected searcher tool (grep, ag, rg, ...). - -CUR-FILE is the path of the current buffer. -PROJ-ROOT is that file's root project directory. -LANG is a string programming language with CONFIG a property list -of project configuration. -ENTERED-NAME is an optional string identifying item to search. -The returned property list has the following members: -- :results: -- :lang : string: language name -- :symbol : string: symbol being searched -- :ctx-type: string: -- :file : string: file name -- :root : string: project root." - (let* ((cur-line-num (line-number-at-pos)) - (found-symbol (or entered-name (dumb-jump-get-point-symbol))) - (look-for (dumb-jump-process-symbol-by-lang lang found-symbol)) - (pt-ctx (if entered-name - (get-text-property 0 :dumb-jump-ctx entered-name) - (dumb-jump-get-point-context - (dumb-jump-get-point-line) - look-for - (dumb-jump--get-symbol-start)))) - (ctx-type - (unless (eq dumb-jump--search-mode 'references) - (dumb-jump-get-ctx-type-by-language lang pt-ctx))) - - (gen-funcs (dumb-jump-pick-grep-variant proj-root)) - (parse-fn (plist-get gen-funcs :parse)) ; dumb-jump-parse-TOOL-response - (generate-fn (plist-get gen-funcs :generate)) - (searcher (plist-get gen-funcs :searcher)) - - (regexes (if (eq dumb-jump--search-mode 'references) - ;; Broad symbol search with a left boundary that also - ;; works for Lisp-family identifiers like *foo*. - (list "(^|[^a-zA-Z0-9\\?\\*-])JJJ\\j") - (dumb-jump-get-contextual-regexes lang ctx-type searcher))) - - ;; If selected searcher has no rules for this language, try alternatives. - ;; Only block fallback when dumb-jump-force-searcher is a direct - ;; searcher symbol. When it's a function or directory list that - ;; didn't match this project, the auto-selected searcher should - ;; still be eligible for fallback. - (_alt-searcher - (when (and (null regexes) - (not (eq dumb-jump--search-mode 'references)) - (not (memq dumb-jump-force-searcher - '(ag rg grep gnu-grep git-grep - git-grep-plus-ag)))) - (let ((alt (seq-find - (lambda (s) - (and (not (eq s searcher)) - (if (eq s 'gnu-grep) - (eq (dumb-jump-grep-installed?) 'gnu) - (funcall (plist-get - (dumb-jump-generators-by-searcher s) - :installed))) - (dumb-jump-get-rules-by-language lang s))) - '(ag rg git-grep gnu-grep grep)))) - (when alt - (setq gen-funcs (dumb-jump-generators-by-searcher alt)) - (setq parse-fn (plist-get gen-funcs :parse)) - (setq generate-fn (plist-get gen-funcs :generate)) - (setq searcher (plist-get gen-funcs :searcher)) - (setq regexes (dumb-jump-get-contextual-regexes - lang ctx-type searcher)))))) - - (exclude-paths (when config (plist-get config :exclude))) - (include-paths (when config (plist-get config :include))) - (rust-dep-paths (when (and (string= lang "rust") - dumb-jump-rust-search-dependencies) - (dumb-jump-get-rust-dependency-paths proj-root))) - (extra-paths - (when dumb-jump-extra-search-paths-function - (let* ((hook-lang (if (and (stringp lang) - (string-match "\\`\\(.+\\)PLUS" lang)) - (match-string 1 lang) - lang)) - (paths (funcall dumb-jump-extra-search-paths-function - hook-lang proj-root))) - (when (listp paths) - (mapcan - (lambda (p) - (when (stringp p) - (let ((expanded (expand-file-name p proj-root))) - (if (file-directory-p expanded) - (list expanded) - (when dumb-jump-debug - (dumb-jump-message - "Dumb Jump: extra-search-paths dropping %S (not a directory)" - expanded)) - nil)))) - paths))))) - ;; we will search proj root and all include paths - (search-paths (seq-uniq (append (list proj-root) - include-paths - (or rust-dep-paths '()) - (or extra-paths '())))) - (_search-paths-debug - (when dumb-jump-debug - (dumb-jump-message "Dumb Jump: search-paths = %S" search-paths))) - (raw-results (mapcan - (lambda (it) - (dumb-jump-run-command look-for it - regexes lang - exclude-paths cur-file - cur-line-num parse-fn - generate-fn)) - search-paths)) - - (results - (let ((deduped (delete-dups - (mapcar (lambda (it) (plist-put it :target look-for)) - raw-results)))) - (if (eq dumb-jump--search-mode 'references) - (dumb-jump-filter-definition-results deduped lang look-for searcher) - deduped)))) - - `(:results ,results - :lang ,(if (null lang) "" lang) - :symbol ,look-for - :ctx-type ,(if (null ctx-type) "" ctx-type) - :file ,cur-file - :root ,proj-root))) - -;;;###autoload -(defun dumb-jump-back () - "Jump back to where the last jump was done." - ;; Note: made obsolete by Emacs `xref-pop-marker-stack'. - (interactive) - (with-demoted-errors "Error running `dumb-jump-before-jump-hook': %S" - (run-hooks 'dumb-jump-before-jump-hook)) - (pop-tag-mark) - (with-demoted-errors "Error running `dumb-jump-after-jump-hook': %S" - (run-hooks 'dumb-jump-after-jump-hook))) - -;;;###autoload -(defun dumb-jump-quick-look () - "Run `dumb-jump-go' in quick look mode. -That is, show a tooltip of where it would jump instead." - ;; Note: independent of the Emacs xref interface. - (interactive) - (with-no-warnings - (dumb-jump-go t))) - -;;;###autoload -(defun dumb-jump-go-other-window () - "Like dumb-jump-go' but use `find-file-other-window' instead of `find-file'." - ;; Note: independent of the Emacs xref interface. - (interactive) - (let ((dumb-jump-window 'other)) - (with-no-warnings - (dumb-jump-go)))) - -;;;###autoload -(defun dumb-jump-go-current-window () - "Like `dumb-jump-go' but always use `find-file'." - ;; Note: independent of the Emacs xref interface. - (interactive) - (let ((dumb-jump-window 'current)) - (with-no-warnings - (dumb-jump-go)))) - -;;;###autoload -(defun dumb-jump-go-prefer-external () - "Like `dumb-jump-go' but prefer external matches from the current file." - ;; Note: independent of the Emacs xref interface. - (interactive) - (with-no-warnings - (dumb-jump-go nil t))) - -;;;###autoload -(defun dumb-jump-find-references () - "Find references/usages of the symbol at point. -This is the inverse of `dumb-jump-go' -- it finds where a symbol -is used rather than where it is defined." - ;; Note: independent of the Emacs xref interface. - (interactive) - (let ((dumb-jump--search-mode 'references) - (dumb-jump-aggressive nil)) - (with-no-warnings - (dumb-jump-go)))) - -;;;###autoload -(defun dumb-jump-go-prompt () - "Like `dumb-jump-go' but prompt for function instead of using under point." - ;; Note: independent of the Emacs xref interface. - (interactive) - (with-no-warnings - (dumb-jump-go nil nil (read-from-minibuffer "Jump to: ")))) - -;;;###autoload -(defun dumb-jump-go-prefer-external-other-window () - "Like `dumb-jump-go-prefer-external' but create another window. -It uses `find-file-other-window' instead of `find-file'." - ;; Note: independent of the Emacs xref interface. - (interactive) - (let ((dumb-jump-window 'other)) - (with-no-warnings - (dumb-jump-go-prefer-external)))) - -;;;###autoload -(defun dumb-jump-go (&optional use-tooltip prefer-external entered-name) - "Go to the function/variable declaration for thing at point. -When USE-TOOLTIP is t a tooltip jump preview will show instead. -When PREFER-EXTERNAL is t it will sort external matches before -current file. -The optional ENTERED-NAME string is the name of the item to jump to -manually selected by user as response to a prompt." - ;; Note: independent of the Emacs xref interface. - (interactive "P") - (let* ((start-time (float-time)) - (info (dumb-jump-get-results entered-name)) - (end-time (float-time)) - (fetch-time (- end-time start-time)) - (results (plist-get info :results)) - (look-for (or entered-name (plist-get info :symbol))) - (proj-root (plist-get info :root)) - (issue (plist-get info :issue)) - (lang (plist-get info :lang)) - (result-count (length results))) - (when (> fetch-time dumb-jump-max-find-time) - (dumb-jump-message - "Took over %ss to find '%s'. \ -Please install ag or rg, or add a .dumbjump file to '%s' with path exclusions" - (number-to-string dumb-jump-max-find-time) look-for proj-root)) - (cond - ((eq issue 'nogrep) - (dumb-jump-message "Please install ag, rg, git grep or grep!")) - ((eq issue 'nosymbol) - (dumb-jump-message "No symbol under point.")) - ((string-suffix-p " file" lang) - (dumb-jump-message "Could not find rules for '%s'." lang)) - ((= result-count 1) - (dumb-jump-result-follow (car results) use-tooltip proj-root)) - ((> result-count 1) - ;; multiple results so let the user pick from a list - ;; unless the match is in the current file - (dumb-jump-handle-results results - (plist-get info :file) - proj-root - (plist-get info :ctx-type) - look-for use-tooltip prefer-external lang)) - ((= result-count 0) - (dumb-jump-message "'%s' %s %s %s not found." - look-for - (if (string-blank-p (or lang "")) - "with unknown language so" - lang) - (plist-get info :ctx-type) - (if (eq dumb-jump--search-mode 'references) - "references" - "declaration")))))) - -(defcustom dumb-jump-language-comments - '((:comment "//" :language "c++") - (:comment "/*" :language "c++") - (:comment ";" :language "elisp") - (:comment ";" :language "commonlisp") - (:comment "//" :language "javascript") - (:comment "//" :language "typescript") - (:comment "//" :language "dart") - (:comment "//" :language "dlang") - (:comment "/*" :language "dlang") - (:comment "/+" :language "dlang") - (:comment "--" :language "haskell") - (:comment "--" :language "lua") - (:comment "//" :language "rust") - (:comment "#" :language "julia") - (:comment "//" :language "objc") - (:comment "//" :language "csharp") - (:comment "//" :language "java") - (:comment ";" :language "clojure") - (:comment "#" :language "coffeescript") - (:comment "//" :language "faust") - (:comment ";" :language "fennel") - (:comment "!" :language "fortran") - (:comment "//" :language "go") - (:comment "//" :language "zig") - (:comment "#" :language "perl") - (:comment "#" :language "tcl") - (:comment "//" :language "php") - (:comment "#" :language "php") - (:comment "--" :language "purescript") - (:comment "#" :language "python") - (:comment "%" :language "matlab") - (:comment "#" :language "r") - (:comment ";" :language "racket") - (:comment "#" :language "ruby") - (:comment "#" :language "crystal") - (:comment "#" :language "nim") - (:comment "#" :language "nix") - (:comment "//" :language "scala") - (:comment ";" :language "scheme") - (:comment "#" :language "janet") - (:comment "#" :language "shell") - (:comment "//" :language "solidity") - (:comment "//" :language "swift") - (:comment "#" :language "elixir") - (:comment "%" :language "erlang") - (:comment "%" :language "tex") - (:comment "//" :language "systemverilog") - (:comment "--" :language "vhdl") - (:comment "//" :language "scss") - (:comment "//" :language "pascal") - (:comment "//" :language "protobuf") - (:comment "#" :language "hcl") - (:comment "//" :language "apex") - (:comment "//" :language "odin") - (:comment "/*" :language "odin") - (:comment "*>" :language "cobol")) - "List of one-line comments organized by language. -A language may have more than 1 comment string." - :group 'dumb-jump - :type - '(repeat - (plist - :options ((:comment string) - (:language string))))) - -(defun dumb-jump-get-comment-by-language (lang) - "Return a list of the one-line comment or comments for the given LANG." - (let* ((entries (seq-uniq - (seq-filter (lambda (it) (string= (plist-get it :language) lang)) - dumb-jump-language-comments)))) - (if (> (length entries) 0) - (mapcar (lambda (pl) (plist-get pl :comment)) entries) - nil))) - -(defun dumb-jump--context-startswith-comment (context-string comments) - "Return t when CONTEXT-STRING starts with any COMMENTS string." - (let ((startswith-comment nil) - ;; trim leading white-space from context-string - (context-str (replace-regexp-in-string "^\\s-+" "" context-string))) - (catch 'found-one - (dolist (comment comments) - (when (string-prefix-p comment context-str) - (setq startswith-comment t) - (throw 'found-one nil)))) - startswith-comment)) - -(defun dumb-jump-filter-no-start-comments (results lang) - "Filter out RESULTS with a :context starting with a LANG comment in file." - (let ((comments (dumb-jump-get-comment-by-language lang))) - (if comments - (seq-filter (lambda (it) - (not (dumb-jump--context-startswith-comment - (plist-get it :context) - comments))) - results) - results))) - -(defun dumb-jump-handle-results (results cur-file proj-root - ctx-type look-for - use-tooltip prefer-external - &optional language) - "Handle the searchers results. -RESULTS is a list of property lists with the searcher's results. -CUR-FILE is the current file within PROJ-ROOT. -CTX-TYPE is a string of the current context. -LOOK-FOR is the symbol we're jumping for. -USE-TOOLTIP shows a preview instead of jumping. -PREFER-EXTERNAL will sort current file last. -LANGUAGE is an optional language to pass to `dumb-jump-process-results'." - (let* ((processed (dumb-jump-process-results results cur-file proj-root - ctx-type look-for use-tooltip - prefer-external language)) - (results (plist-get processed :results)) - (do-var-jump (plist-get processed :do-var-jump)) - (var-to-jump (plist-get processed :var-to-jump)) - (match-cur-file-front (plist-get processed :match-cur-file-front))) - (dumb-jump-debug-message - look-for - ctx-type - var-to-jump - (pp-to-string match-cur-file-front) - (pp-to-string results) - prefer-external - proj-root - cur-file) - (cond - (use-tooltip ;; quick-look mode - (let* ((choices (mapcar (lambda (it) (dumb-jump--format-result proj-root it)) results)) - (selected-choice (dumb-jump--select-choice choices "Matches: ")) - (selected-result (cdr (assoc selected-choice - (dumb-jump--zip-pair choices results))))) - (when selected-result - (dumb-jump--show-preview - (dumb-jump--format-result proj-root selected-result))))) - (do-var-jump - (dumb-jump-result-follow var-to-jump use-tooltip proj-root)) - (t - (dumb-jump-prompt-user-for-choice proj-root match-cur-file-front))))) - -(defun dumb-jump--candidate-x<y (x y) - "Return non-nil if candidate X should sort before candidate Y. -Order by :path length (shorter first), then by :line." - (let ((x-path-len (length (plist-get x :path))) - (y-path-len (length (plist-get y :path)))) - (if (/= x-path-len y-path-len) - (< x-path-len y-path-len) - (< (plist-get x :line) - (plist-get y :line))))) - -(defun dumb-jump-process-results (results cur-file proj-root ctx-type - _look-for _use-tooltip - prefer-external &optional language) - "Process (filter, sort, ...) the searchers results. -RESULTS is a list of property lists with the searcher's results. -CUR-FILE is the current file within PROJ-ROOT. -CTX-TYPE is a string of the current context. -LOOK-FOR is the symbol we're jumping for. -USE-TOOLTIP shows a preview instead of jumping. -PREFER-EXTERNAL will sort current file last. -LANGUAGE is the optional given language, if nil it will be found by -`dumb-jump-get-language-by-filename'. -Figure which of the RESULTS to jump to. Favoring the CUR-FILE." - (let* ((lang (if language language - (dumb-jump-get-language-by-filename cur-file))) - (match-sorted (seq-sort (lambda (x y) - (< (plist-get x :diff) (plist-get y :diff))) - results)) - (match-no-comments (dumb-jump-filter-no-start-comments match-sorted - lang)) - - ;; Find the relative current file path by the project root. - ;; In some cases the results will not be absolute but relative and - ;; the "current file" filters must match in both cases. Also works - ;; when current file is in an arbitrary sub folder. - (rel-cur-file - (cond ((and (string-prefix-p proj-root cur-file) - (string-prefix-p default-directory cur-file)) - (substring cur-file - (length default-directory) - (length cur-file))) - - ((and (string-prefix-p proj-root cur-file) - (not (string-prefix-p default-directory cur-file))) - (substring cur-file - (1+ (length proj-root)) - (length cur-file))) - - (t - cur-file))) - - ;; Moves current file results to the front of the list, unless - ;; PREFER-EXTERNAL then put them last. - (match-cur-file-front - (if (not prefer-external) - (append - (seq-filter (lambda (it) - (and (> (plist-get it :diff) 0) - (or (string= (plist-get it :path) cur-file) - (string= (plist-get it :path) rel-cur-file)))) - match-no-comments) - (seq-filter (lambda (it) - (and (<= (plist-get it :diff) 0) - (or (string= (plist-get it :path) cur-file) - (string= (plist-get it :path) rel-cur-file)))) - match-no-comments) - (seq-sort #'dumb-jump--candidate-x<y - (seq-filter (lambda (it) - (not (or (string= (plist-get it :path) cur-file) - (string= (plist-get it :path) rel-cur-file)))) - match-no-comments))) - (append - (seq-sort #'dumb-jump--candidate-x<y - (seq-filter (lambda (it) - (not (or (string= (plist-get it :path) cur-file) - (string= (plist-get it :path) rel-cur-file)))) - match-no-comments)) - (seq-filter (lambda (it) - (or (string= (plist-get it :path) cur-file) - (string= (plist-get it :path) rel-cur-file))) - match-no-comments)))) - - (matches - (if (not prefer-external) - (seq-uniq - (append - (dumb-jump-current-file-results cur-file match-cur-file-front) - (dumb-jump-current-file-results rel-cur-file match-cur-file-front))) - match-cur-file-front)) - - (var-to-jump (car matches)) - ;; TODO: handle if ctx-type is null but ALL results are variable - - ;; When non-aggressive it should only jump when there is only one - ;; match, regardless of context. - (do-var-jump - (and (or dumb-jump-aggressive - (= (length match-cur-file-front) 1)) - (or (= (length matches) 1) - (string= ctx-type "variable") - (string= ctx-type "")) - var-to-jump))) - - (list :results results - :do-var-jump do-var-jump - :var-to-jump var-to-jump - :match-cur-file-front match-cur-file-front))) - -(declare-function tramp-file-name-localname "tramp") -(declare-function tramp-dissect-file-name "tramp") - -(defun dumb-jump-read-config (root config-file) - "Load and return options (exclusions, inclusions, etc). -Ffrom the ROOT project CONFIG-FILE." - (with-temp-buffer - (insert-file-contents (expand-file-name config-file root)) - (let ((local-root (if (file-remote-p root) - (progn - (require 'tramp) - (tramp-file-name-localname - (tramp-dissect-file-name root))) - root)) - include exclude lang) - (while (not (eobp)) - (cond ((looking-at "^language \\\(.+\\\)") - (setq lang (match-string 1))) - ((looking-at "^\\+\\(.+\\)") - (push (expand-file-name (match-string 1) local-root) - include)) - ((looking-at "^-/?\\(.+\\)") - (push (expand-file-name (match-string 1) local-root) - exclude))) - (forward-line)) - (list :exclude (nreverse exclude) - :include (nreverse include) - :language lang)))) - -(defun dumb-jump-file-modified-p (path) - "Return non-nil if file at PATH is open in Emacs and has a modified buffer." - (seq-some (lambda (it) - (and (buffer-modified-p it) - (buffer-file-name it) - (file-exists-p (buffer-file-name it)) - (file-equal-p (buffer-file-name it) path))) - (buffer-list))) - -(defun dumb-jump-result-follow (result &optional use-tooltip proj) - "Jump to location identified by RESULT. -Before jumping, record the jump to be able to jump back later. - -If destination buffer was modified, prompt user to proceed if the -`dumb-jump-confirm-jump-to-modified-file' user-option is non-nil, -otherwise display a warning. - -With optional USE-TOOLTIP non-nil, pop a tool-tip showing the project -PROJ and RESULT information." - (if (dumb-jump-file-modified-p (plist-get result :path)) - (let ((target-file (plist-get result :path))) - (if dumb-jump-confirm-jump-to-modified-file - (when (y-or-n-p - (concat - target-file - " has been modified so we may have the wrong location. Continue?")) - (dumb-jump--result-follow result use-tooltip proj)) - (message - "Warning: %s has been modified so we may have the wrong location." - target-file) - (dumb-jump--result-follow result use-tooltip proj))) - (dumb-jump--result-follow result use-tooltip proj))) - -(defun dumb-jump--result-follow (result &optional use-tooltip proj) - "Jump to location identified by RESULT. -Before jumping, record the jump to be able to jump back later. - -With optional USE-TOOLTIP non-nil, pop a tool-tip showing the project -PROJ and RESULT information." - (let* ((target-boundary (dumb-jump--matched-positions-all - (concat "\\b" - (regexp-quote (plist-get result :target)) - "\\b") - (plist-get result :context))) - ;; column position is either via tpos from ag or by using the regex - ;; above or last using old dumb-jump--index-of - (column (if target-boundary - (car (car target-boundary)) - (dumb-jump--index-of (plist-get result :target) - (plist-get result :context)))) - - (result-path (plist-get result :path)) - - ;; Return value is either a string like "/ssh:user@1.2.3.4:" or nil - (tramp-path-prefix (file-remote-p default-directory)) - - ;; If result-path is an absolute path, the prefix is added to the head of it, - ;; or result-path is added to the end of default-directory - (path-for-tramp (when (and result-path tramp-path-prefix) - (if (file-name-absolute-p result-path) - (concat tramp-path-prefix result-path) - (concat default-directory result-path)))) - - (thef (or path-for-tramp result-path)) - (line (plist-get result :line))) - (when thef - (if use-tooltip - (dumb-jump--show-preview (dumb-jump--format-result proj result)) - (dumb-jump-goto-file-line thef line column))) - ;; return the file for test - thef)) - -(defun dumb-jump-goto-file-line (thefile theline column) - "Open THEFILE, move point to line THELINE at COLUMN. -Push current position to the xref marker stack. -Run the `dumb-jump-before-jump-hook' hooks before jumping and -the `dumb-jump-after-jump-hook' hooks after the jump." - (xref-push-marker-stack) - ;; Run the before-jump hooks - (with-demoted-errors "Error running `dumb-jump-before-jump-hook': %S" - (run-hooks 'dumb-jump-before-jump-hook)) - ;; Open THEFILE in a buffer and a window specified by user-options. - (let* ((visible-buffer (find-buffer-visiting thefile)) - (visible-window (when visible-buffer - (get-buffer-window visible-buffer)))) - (cond - ((and visible-window dumb-jump-use-visible-window) - (select-window visible-window)) - ((eq dumb-jump-window 'other) - (find-file-other-window thefile)) - (t (find-file thefile)))) - ;; Move point to THELINE at COLUMN - (goto-char (point-min)) - (forward-line (1- theline)) - (forward-char column) - ;; Run the after-jump hooks - (with-demoted-errors "Error running `dumb-jump-after-jump-hook': %S" - (run-hooks 'dumb-jump-after-jump-hook))) - -(defun dumb-jump-current-file-results (path results) - "Return the PATH's RESULTS." - (let ((matched (seq-filter (lambda (it) (string= path (plist-get it :path))) results))) - matched)) - -(defun dumb-jump-generators-by-searcher (searcher) - "Return action property list for specific SEARCHER. - -- SEARCHER: symbol: the name of the search tool. - One of: git-grep, ag, git-grep-plus-ag, rg, gnu-grep, grep. -The returned plist has: -- :parse : function: response parser. -- :generate : function: search command string generator. These functions - accept 6 arguments: look-for, cur-file, proj, - regexes, lang, exclude-paths. -- :installed : predicate installed? function: is searcher installed? -- :searcher : symbol : the SEARCHER (see above)." - (cond ((equal 'git-grep searcher) - `(:parse ,'dumb-jump-parse-git-grep-response - :generate ,'dumb-jump-generate-git-grep-command - :installed ,'dumb-jump-git-grep-installed? - :searcher ,searcher)) - ((equal 'ag searcher) - `(:parse ,'dumb-jump-parse-ag-response - :generate ,'dumb-jump-generate-ag-command - :installed ,'dumb-jump-ag-installed? - :searcher ,searcher)) - ((equal 'git-grep-plus-ag searcher) - `(:parse ,'dumb-jump-parse-ag-response - :generate ,'dumb-jump-generate-git-grep-plus-ag-command - :installed ,'dumb-jump-git-grep-plus-ag-installed? - :searcher ,searcher)) - ((equal 'rg searcher) - `(:parse ,'dumb-jump-parse-rg-response - :generate ,'dumb-jump-generate-rg-command - :installed ,'dumb-jump-rg-installed? - :searcher ,searcher)) - ((equal 'gnu-grep searcher) - `(:parse ,'dumb-jump-parse-grep-response - :generate ,'dumb-jump-generate-gnu-grep-command - :installed ,'dumb-jump-grep-installed? - :searcher ,searcher)) - ((equal 'grep searcher) - `(:parse ,'dumb-jump-parse-grep-response - :generate ,'dumb-jump-generate-grep-command - :installed ,'dumb-jump-grep-installed? - :searcher ,searcher)))) - -(defun dumb-jump-selected-grep-variant (&optional proj-root) - "Return search tool for current project or specified PROJ-ROOT. -Select search tool according to `dumb-jump-prefer-searcher' choice and its -possible `dumb-jump-force-searcher' overriding." - (let ((searcher-found nil)) - (cond - ;; If `dumb-jump-force-searcher' is not nil then use the searcher - ;; identified by that user-option if possible. - (dumb-jump-force-searcher - (cond - ;; Honour forced choices, they might be identified in dir-local file - ((member dumb-jump-force-searcher '(ag - rg - grep - gnu-grep - git-grep - git-grep-plus-ag)) - (setq searcher-found dumb-jump-force-searcher)) - ;; Select search tool identified by calling the user-specified function - ;; which takes the directory. - ((and (symbolp dumb-jump-force-searcher) - (fboundp dumb-jump-force-searcher)) - (let ((user-selected-search-tool - (funcall dumb-jump-force-searcher (or proj-root - (buffer-file-name))))) - (when user-selected-search-tool - (setq searcher-found user-selected-search-tool)))) - ;; Check if project root or current directory is inside one of the - ;; project roots specified - ((and (listp dumb-jump-force-searcher) - proj-root - (dumb-jump-git-grep-installed?) - (member (dumb-jump-get-project-root proj-root) - dumb-jump-force-searcher) - (file-exists-p (expand-file-name ".git" proj-root))) - ;; [:todo 2026-01-07, by Pierre Rouleau: add support for git grep + ag??] - (setq searcher-found 'git-grep))))) - - (unless searcher-found - ;; When `dumb-jump-force-searcher' does not override the selection, then - ;; select the searcher based on the value of `dumb-jump-force-searcher'. - (cond - ;; If `dumb-jump-prefer-searcher' identifies a searcher use it if it's - ;; installed. - ((and dumb-jump-prefer-searcher - (funcall (plist-get (dumb-jump-generators-by-searcher - dumb-jump-prefer-searcher) - :installed))) - (setq searcher-found dumb-jump-prefer-searcher)) - - ;; Fallback searcher order. - ((dumb-jump-ag-installed?) (setq searcher-found 'ag)) - ((dumb-jump-rg-installed?) (setq searcher-found 'rg)) - ((eq (dumb-jump-grep-installed?) 'gnu) (setq searcher-found 'gnu-grep)) - (t (setq searcher-found 'grep)))) - ;; return the symbol identifying the selected search tool - searcher-found)) - -(defun dumb-jump-pick-grep-variant (&optional proj-root) - "Get action search property list for current project or specified PROJ-ROOT. -Select search tool according to `dumb-jump-prefer-searcher' choice and its -possible `dumb-jump-force-searcher' overriding." - (dumb-jump-generators-by-searcher - (dumb-jump-selected-grep-variant proj-root))) - -(defun dumb-jump-shell-command-switch () - "Return current shell command switch prevent loading shell profile/RC. -Using that switch speeds shell command execution. -The `shell-file-name' identifies the current shell." - (let ((base-name (downcase (file-name-base shell-file-name)))) - (cond - ((or (string-equal "zsh" base-name) - (string-equal "csh" base-name) - (string-equal "tcsh" base-name)) - "-icf") - ;; - ((string-equal "bash" base-name) - "-c") - ;; - (t - shell-command-switch)))) - -(defconst dumb-jump--case-insensitive-languages - '("commonlisp" - "cobol") - "List of case insensitive languages.") - -;; TODO: rename dumb-jump-run-definition-command -(defun dumb-jump-run-command (look-for proj regexes lang - exclude-args cur-file - line-num parse-fn generate-fn) - "Run the grep search command based on LOOK-FOR in the directory TOSEARCH. -The parameters are: -- LOOK-FOR: string: searched symbol -- PROJ: string: directory path -- REGEXES: list of strings: each string is a dumb-jump generic regular - expression. -- LANG: string: handled language name specified in `dumb-jump-find-rules'. -- EXCLUDE-ARGS: -- CUR-FILE string: current file name. -- LINE-NUM: integer: current line number. -- PARSE-FN: the parse function; something like `dumb-jump-parse-grep-response'. -- GENERATE-FN: the generate function; - something like `dumb-jump-generate-ag-command'." - (let* ((proj-root (if (file-remote-p proj) - (directory-file-name - (tramp-file-name-localname (tramp-dissect-file-name proj))) - proj)) - (cmd (funcall generate-fn look-for cur-file proj-root regexes lang exclude-args)) - (shell-command-switch (dumb-jump-shell-command-switch)) - (rawresults "")) - - (dumb-jump-debug-message cmd) - (setq rawresults (shell-command-to-string cmd)) - (dumb-jump-debug-message rawresults) - (when (string-match-p "^PCRE2 is not available" rawresults) - (dumb-jump-message "dumb-jump: Ripgrep PCRE2 support is not available. Install ripgrep with PCRE2 support or customize `dumb-jump-rg-search-args' to remove \"--pcre2\".") - (dumb-jump-env-problem "Ripgrep PCRE2 support is not available in the current build.")) - (when (and (string-blank-p rawresults) - dumb-jump-fallback-search - (not (eq dumb-jump--search-mode 'references))) - (setq regexes (list dumb-jump-fallback-regex)) - (setq cmd (funcall generate-fn - look-for cur-file - proj-root regexes - lang exclude-args)) - (dumb-jump-debug-message cmd) - (setq rawresults (shell-command-to-string cmd)) - (dumb-jump-debug-message rawresults)) - (unless (string-blank-p (or cmd "")) - (let ((results (funcall parse-fn rawresults cur-file line-num)) - (ignore-case (member lang dumb-jump--case-insensitive-languages))) - (seq-filter (lambda (it) - (dumb-jump--contains-p look-for - (plist-get it :context) ignore-case)) - results))))) - -(defun dumb-jump-parse-response-line (resp-line cur-file) - "Parse a search program's single RESP-LINE for CUR-FILE. -Return a list of (path line context)." - (let* ((parts (seq-remove (lambda (it) (string= it "")) - (dumb-jump--split "\\(?:^\\|:\\)[0-9]+:" resp-line))) - (line-num-raw (dumb-jump--match "\\(?:^\\|:\\)\\([0-9]+\\):" resp-line)) - (line-num (and line-num-raw - (> (length line-num-raw) 1) - (nth 1 line-num-raw)))) - - (cond - ;; fixes rare bug where context is blank but file is defined "/somepath/file.txt:14:" - ;; OR: (and (= (length parts) 1) (file-name-exists (nth 0 parts))) - ((dumb-jump--match ":[0-9]+:$" resp-line) - nil) - ((and parts line-num) - (if (= (length parts) 2) - (list (let ((path (expand-file-name (nth 0 parts)))) - (if (file-name-absolute-p (nth 0 parts)) - path - (file-relative-name path))) - line-num (nth 1 parts)) - ; this case is when they are searching a particular file... - (list (let ((path (expand-file-name cur-file))) - (if (file-name-absolute-p cur-file) - path - (file-relative-name path))) - line-num (nth 0 parts))))))) - -;; -- -;; Parse Search Tool Results: indirectly called by `dumb-jump-run-command' -;; ----------------------------------------------------------------------- -;; - `dumb-jump-parse-grep-response' -;; - `dumb-jump-parse-ag-response' -;; - `dumb-jump-parse-rg-response' -;; - `dumb-jump-parse-git-grep-response' -;; - `dumb-jump-parse-response-lines' - -(defun dumb-jump-parse-response-lines (parsed cur-file cur-line-num) - "Turn PARSED response lines into a list of property lists. -Using CUR-FILE and CUR-LINE-NUM to exclude jump origin." - (let* ((records (mapcan - (lambda (it) - (when it - (let* ((line-num (string-to-number (nth 1 it))) - (diff (- cur-line-num line-num))) - (list `(:path ,(nth 0 it) - :line ,line-num - :context ,(nth 2 it) - :diff ,diff))))) - parsed)) - (results (delq nil records))) - (seq-filter - (lambda (it) - (not (and - (string= (plist-get it :path) cur-file) - (= (plist-get it :line) cur-line-num)))) - results))) - -(defun dumb-jump-parse-grep-response (resp cur-file cur-line-num) - "Parse raw grep search response RESP into a list of plists. -- CUR-FILE: current file. -- CUR-LINE-NUM: current line number." - (let* ((resp-no-warnings - (seq-filter (lambda (it) - (and (not (string-prefix-p "grep:" it)) - (not (dumb-jump--contains-p "No such file or" it)))) - (dumb-jump--split "\n" (dumb-jump--trim resp)))) - (parsed (mapcar (lambda (it) (dumb-jump-parse-response-line it cur-file)) - resp-no-warnings))) - (dumb-jump-parse-response-lines parsed cur-file cur-line-num))) - -(defun dumb-jump--clean-wsl-response (resp) - "Clean up RESP for Windows WSL/UNC path issues. -Filters CMD.exe UNC path warnings and fixes /wsl$/ to //wsl$/." - (let* ((cleaned (replace-regexp-in-string - "CMD\\.EXE was started with the above path as the current directory\\.\nUNC paths are not supported\\..*?\n" - "" resp)) - (fixed (replace-regexp-in-string "^/wsl\\$/" "//wsl$/" cleaned))) - (replace-regexp-in-string "\n/wsl\\$/" "\n//wsl$/" fixed))) - -(defun dumb-jump-parse-ag-response (resp cur-file cur-line-num) - "Parse raw ag search response RESP into a list of plists. -- CUR-FILE: current file. -- CUR-LINE-NUM: current line number." - (let* ((cleaned (dumb-jump--clean-wsl-response resp)) - (resp-lines (dumb-jump--split "\n" (dumb-jump--trim cleaned))) - (parsed (mapcar (lambda (it) (dumb-jump-parse-response-line it cur-file)) - resp-lines))) - (dumb-jump-parse-response-lines parsed cur-file cur-line-num))) - -(defun dumb-jump-parse-rg-response (resp cur-file cur-line-num) - "Parse raw rg search response RESP into a list of plists. -- CUR-FILE: current file. -- CUR-LINE-NUM: current line number." - (let* ((resp-lines (dumb-jump--split "\n" (dumb-jump--trim resp))) - (parsed (mapcar (lambda (it) (dumb-jump-parse-response-line it cur-file)) - resp-lines))) - (dumb-jump-parse-response-lines parsed cur-file cur-line-num))) - -(defun dumb-jump-parse-git-grep-response (resp cur-file cur-line-num) - "Parse raw git grep response RESP into a list of plists. -- CUR-FILE: current file. -- CUR-LINE-NUM: current line number." - (let* ((resp-lines (dumb-jump--split "\n" (dumb-jump--trim resp))) - (parsed (mapcar (lambda (it) (dumb-jump-parse-response-line it cur-file)) - resp-lines))) - (dumb-jump-parse-response-lines parsed cur-file cur-line-num))) - -;; -- - -(defun dumb-jump-re-match (re s) - "Does regular expression RE match string S. If RE is nil return nil." - (when (and re s) - (dumb-jump--match re s))) - -(defun dumb-jump-get-ctx-type-by-language (lang pt-ctx) - "Detect the type of context by the language LANG and its context PT-CTX. -PT-CTX is assumed to be a property list with the :left and :right attributes -that are both strings." - (let* ((contexts (seq-filter (lambda (it) - (string= (plist-get it ':language) lang)) - dumb-jump-language-contexts)) - (usable-ctxs - (when (> (length contexts) 0) - (seq-filter (lambda (it) - (and (or (null (plist-get it :left)) - (dumb-jump-re-match (plist-get it :left) - (plist-get pt-ctx :left))) - (or (null (plist-get it :right)) - (dumb-jump-re-match (plist-get it :right) - (plist-get pt-ctx :right))))) - contexts))) - (use-ctx (= (length (seq-filter - (lambda (it) - (string= (plist-get it ':type) - (and usable-ctxs (plist-get (car usable-ctxs) :type)))) - usable-ctxs)) - (length usable-ctxs)))) - - (when (and usable-ctxs use-ctx) - (plist-get (car usable-ctxs) :type)))) - -(defun dumb-jump-get-ext-includes (language) - "Return the --include grep argument of file extensions for LANGUAGE." - (let ((exts (dumb-jump-get-file-exts-by-language language))) - (dumb-jump-arg-joiner - "--include" - (mapcar (lambda (it) (format "\\*.%s" it)) exts)))) - -(defun dumb-jump-arg-joiner (prefix values) - "Helper to generate command arg with its PREFIX for each value in VALUES." - (let* ((normalized-values (mapcar (lambda (it) (dumb-jump--trim (or it ""))) values)) - (non-empty-values (seq-filter (lambda (it) (> (length it) 0)) normalized-values)) - (args (dumb-jump--join (format " %s " prefix) non-empty-values))) - (if non-empty-values - (format " %s %s " prefix args) - ""))) - -(defun dumb-jump-get-contextual-regexes (lang ctx-type searcher) - "Get list of search regular expressions by LANG and CTX-TYPE. -The arguments are: -- LANG: string: the language. -- CTX-TYPE: variable, function, etc. -- SEARCHER: symbol: the name of the search tool. - One of: git-grep, ag, git-grep-plus-ag, rg, gnu-grep, grep." - (let* ((raw-rules (dumb-jump-get-rules-by-language lang searcher)) - (ctx-type (unless dumb-jump-ignore-context ctx-type)) - (ctx-rules - (if ctx-type - (seq-filter (lambda (it) (string= (plist-get it :type) ctx-type)) raw-rules) - raw-rules)) - (rules (or ctx-rules raw-rules)) - (regexes (mapcar (lambda (it) (plist-get it :regex)) rules))) - regexes)) - -(defun dumb-jump-populate-regex (it look-for variant) - "Populate IT regex template with LOOK-FOR for the specific search VARIANT. -Replace the dumb-jump generic regular expression meta concepts with the -one required for the search variant tool. -The arguments are: -- IT : string: the dumb-jump generic regular expression. -- LOOK-FOR: string: the searched item. -- VARIANT : symbol: the search tool variant, - one of: ag, rg, grep, gnu-grep, git-grep-plus-ag, git-grep." - (let ((boundary - (cond ((eq variant 'rg) dumb-jump-rg-word-boundary) - ((eq variant 'ag) dumb-jump-ag-word-boundary) - ((eq variant 'git-grep-plus-ag) dumb-jump-ag-word-boundary) - ((eq variant 'git-grep) dumb-jump-git-grep-word-boundary) - (t dumb-jump-grep-word-boundary)))) - (let ((text it)) - (setq text (dumb-jump--replace "\\j" boundary text)) - (when (dumb-jump-use-space-bracket-exp-for variant) - (setq text (dumb-jump--replace "\\s" "[[:space:]]" text))) - (setq text (dumb-jump--replace "JJJ" (regexp-quote look-for) text)) - text))) - -(defun dumb-jump-populate-regexes (look-for regexes variant) - "Return list of VARIANT specific regexes from the dumb-jump generic REGEXES. -Update the generic regexes, populate the target identified in LOOK-FOR. -The arguments are: -- LOOK-FOR: string: the searched item. -- REGEXES: list of strings: each string is a dumb-jump generic regular - expression. -- VARIANT: symbol: the search tool variant, - one of: ag, rg, git-grep-plus-ag, git-grep." - (mapcar - (lambda (it) - (dumb-jump-populate-regex it look-for variant)) - regexes)) - -(defun dumb-jump-pcre-to-emacs (regex) - "Convert a PCRE-style REGEX string to Emacs regex syntax. -In PCRE and Emacs, +, ?, *, ., ^, $, [ are special without escaping. -But (, ), |, {, } differ: special unescaped in PCRE, special escaped in Emacs. -This function swaps the literal/special meaning of (, ), |, {, and }." - (let ((i 0) - (len (length regex)) - (out (list))) - (while (< i len) - (let ((ch (aref regex i))) - (cond - ;; Backslash sequence - ((and (= ch ?\\) (< (1+ i) len)) - (let ((next (aref regex (1+ i)))) - (cond - ((memq next '(?\( ?\) ?| ?{ ?})) - ;; \X (literal in PCRE) → X (literal in Emacs) - (push (char-to-string next) out) - (setq i (+ i 2))) - (t - ;; Other backslash sequences (\b, \w, \+, \?, etc.) pass through - (push (substring regex i (+ i 2)) out) - (setq i (+ i 2)))))) - ;; (? prefixed groups: (?:, (?!, (?=, (?<=, (?<!, etc. - ;; Emit \(? which in Emacs starts a shy group for (?: - ;; and produces a valid (if semantically different) group for others. - ((and (= ch ?\() - (< (1+ i) len) - (= (aref regex (1+ i)) ??)) - (push "\\(?" out) - (setq i (+ i 2))) - ;; Unescaped chars that differ between PCRE and Emacs - ((= ch ?\() (push "\\(" out) (cl-incf i)) - ((= ch ?\)) (push "\\)" out) (cl-incf i)) - ((= ch ?|) (push "\\|" out) (cl-incf i)) - ((= ch ?{) (push "\\{" out) (cl-incf i)) - ((= ch ?}) (push "\\}" out) (cl-incf i)) - ;; Everything else passes through (including +, ?, *, ., etc.) - (t (push (char-to-string ch) out) (cl-incf i))))) - (apply #'concat (nreverse out)))) - -(defun dumb-jump-populate-regex-for-emacs (regex look-for) - "Populate dumb-jump generic REGEX to match LOOK-FOR with `string-match-p'. -Replaces dumb-jump meta-patterns and converts PCRE syntax to Emacs regex. -The \\=\\j boundary is replaced after PCRE conversion with a character class -matching the tool boundaries: not followed by [a-zA-Z0-9?*-]." - (let ((text regex)) - (setq text (dumb-jump--replace "\\s" "[[:space:]]" text)) - (setq text (dumb-jump--replace "JJJ" (regexp-quote look-for) text)) - (setq text (dumb-jump-pcre-to-emacs text)) - ;; Replace \j after PCRE conversion since the replacement is Emacs syntax. - ;; Mirrors the tool boundaries: (?![a-zA-Z0-9\?\*-]) for ag, - ;; ($|[^a-zA-Z0-9\?\*-]) for rg/grep. - (setq text (dumb-jump--replace "\\j" "\\(?:[^a-zA-Z0-9?*-]\\|$\\)" text)) - text)) - -(defun dumb-jump-filter-definition-results (results lang look-for _searcher) - "Remove from RESULTS any that match definition patterns for LANG. -LOOK-FOR is the symbol being searched. _SEARCHER is unused but kept for API." - (let* ((raw-rules (seq-remove - (lambda (it) (plist-get it :skip-ref-filter)) - (seq-filter (lambda (it) - (string= (plist-get it :language) lang)) - dumb-jump-find-rules))) - (def-regexes (seq-uniq (mapcar (lambda (it) (plist-get it :regex)) raw-rules))) - (emacs-regexes (mapcar (lambda (re) - (dumb-jump-populate-regex-for-emacs re look-for)) - def-regexes))) - (seq-filter - (lambda (r) - (let ((ctx (plist-get r :context))) - (not (seq-some (lambda (re) - (condition-case nil - (string-match-p re ctx) - (invalid-regexp nil))) - emacs-regexes)))) - results))) - -;; -- -(defun dumb-jump-generate-ag-command (look-for - cur-file proj - regexes lang - exclude-paths) - "Return the ag command to search for LOOK-FOR in the PROJ directory. -The arguments are: -- LOOK-FOR: string: the searched item. -- CUR-FILE: string: current file name. Used to check if it's compressed. -- PROJ: string: project root path. -- REGEXES: list of strings: each string is a dumb-jump generic regular - expression. -- LANG: string: handled language. -- EXCLUDE-PATHS: list of strings: directories to exclude from search." - (let* ((filled-regexes (dumb-jump-populate-regexes look-for regexes 'ag)) - (agtypes (dumb-jump-get-ag-type-by-language lang)) - (lang-exts (dumb-jump-get-file-exts-by-language lang)) - (proj-dir (file-name-as-directory proj)) - ;; TODO: --search-zip always? in case the include is the in gz area - ;; like emacs lisp code. - (cmd (concat dumb-jump-ag-cmd - " --nocolor --nogroup" - (if (member lang dumb-jump--case-insensitive-languages) - " --ignore-case" - "") - (if (string-suffix-p ".gz" cur-file) - " --search-zip" - "") - (unless (string-blank-p dumb-jump-ag-search-args) - (concat " " dumb-jump-ag-search-args)) - (if agtypes - (dumb-jump--join "" (mapcar (lambda (it) (format " --%s" it)) agtypes)) - (concat " -G '(" - (dumb-jump--join "|" - (mapcar (lambda (it) (format "\\.%s" it)) lang-exts)) - ")$'")))) - (exclude-args (dumb-jump-arg-joiner - "--ignore-dir" - (mapcar - (lambda (it) - (shell-quote-argument (dumb-jump--replace proj-dir "" it))) - exclude-paths))) - (regex-args (shell-quote-argument (dumb-jump--join "|" filled-regexes)))) - (if (null regexes) - "" - (dumb-jump-concat-command cmd exclude-args "--" regex-args (shell-quote-argument proj))))) - -;; -- -(defun dumb-jump-get-git-grep-files-matching-symbol (symbol proj-root) - "Return a list of file names in PROJ-ROOT holding the literal SYMBOL. -Search for matching files using git grep." - (let* ((cmd (format "git grep --full-name -F -c %s %s" - (shell-quote-argument symbol) (shell-quote-argument proj-root))) - (result (dumb-jump--trim (shell-command-to-string cmd))) - ;; result: '\n\ separated lines of: "path-name:count" - ;; extract the name of files and return them in a list. - (matched-files (mapcar - (lambda (it) - (cl-first (dumb-jump--split ":" it))) - (dumb-jump--split "\n" result)))) - matched-files)) - -(defun dumb-jump-format-files-as-ag-arg (files proj-root) - "Take a list of FILES and their PROJ-ROOT and return a `ag -G` argument." - (format "'(%s)'" (dumb-jump--join "|" (mapcar (lambda (it) - (file-relative-name - (expand-file-name it proj-root))) - files)))) - -(defun dumb-jump-get-git-grep-files-matching-symbol-as-ag-arg (symbol proj-root) - "Return optimized `ag -G` argument string to search for SYMBOL in PROJ-ROOT. -Limit the ag search to files matching SYMBOL in PROJ-ROOT by first getting the -list of files with `git grep`. -The string does not contain the `ag -G`, just its argument." - (dumb-jump-format-files-as-ag-arg - (dumb-jump-get-git-grep-files-matching-symbol symbol proj-root) - proj-root)) - - -;; git-grep plus ag only recommended for huge repos like the linux kernel. -(defun dumb-jump-generate-git-grep-plus-ag-command (look-for - cur-file proj - regexes lang - exclude-paths) - "Return the ag command to search for LOOK-FOR in the PROJ directory. -Using ag to search only the files found via git-grep literal symbol search. -Note: Only recommended for huge repos like the linux kernel. -The arguments are: -- LOOK-FOR: string: the searched text -- CUR-FILE: -- PROJ: string: project root path. -- REGEXES: list of strings: each string is a dumb-jump generic regular - expression. -- LANG: string: handled language. -- EXCLUDE_PATHS: list of strings: directories to exclude from search." - (let* ((filled-regexes (dumb-jump-populate-regexes look-for regexes 'ag)) - (proj-dir (file-name-as-directory proj)) - (ag-files-arg - (dumb-jump-get-git-grep-files-matching-symbol-as-ag-arg - look-for proj-dir)) - (cmd (concat dumb-jump-ag-cmd - " --nocolor --nogroup" - (if (member lang dumb-jump--case-insensitive-languages) - " --ignore-case" - "") - (if (string-suffix-p ".gz" cur-file) - " --search-zip" - "") - " -G " ag-files-arg - " ")) - (exclude-args (dumb-jump-arg-joiner - "--ignore-dir" - (mapcar - (lambda (it) - (shell-quote-argument (dumb-jump--replace proj-dir "" it))) - exclude-paths))) - (regex-args (shell-quote-argument (dumb-jump--join "|" filled-regexes)))) - (if (null regexes) - "" - (dumb-jump-concat-command cmd exclude-args regex-args (shell-quote-argument proj))))) - -;; -- -(defun dumb-jump-generate-rg-command (look-for - _cur-file proj - regexes lang - exclude-paths) - "Return the rg command to search for LOOK-FOR in the PROJ directory. -The arguments are: -- LOOK-FOR: string: the searched item. -- CUR-FILE: -- PROJ: string: project root path. -- REGEXES: list of strings: each string is a dumb-jump generic regular - expression. -- LANG: string: handled language. -- EXCLUDE-PATHS: list of strings: directories to exclude from search." - (let* ((filled-regexes (dumb-jump-populate-regexes look-for regexes 'rg)) - (rgtypes (dumb-jump-get-rg-type-by-language lang)) - (rg-nontype-exts (dumb-jump-get-rg-nontype-exts-by-language lang)) - (proj-dir (file-name-as-directory proj)) - (cmd (concat dumb-jump-rg-cmd - " --color never --no-heading --line-number -U" - (if (member lang dumb-jump--case-insensitive-languages) - " --ignore-case" - "") - (unless (string-blank-p dumb-jump-rg-search-args) - (concat " " dumb-jump-rg-search-args)) - (dumb-jump--join "" (mapcar (lambda (it) (format " --type %s" it)) rgtypes)) - (if rgtypes "" - (dumb-jump--join "" (mapcar (lambda (it) (format " -g \"*.%s\"" it)) rg-nontype-exts))))) - (exclude-args (dumb-jump-arg-joiner - "-g" - (mapcar - (lambda (it) - (shell-quote-argument - (concat "!" (dumb-jump--replace proj-dir "" it)))) - exclude-paths))) - (regex-args (shell-quote-argument (dumb-jump--join "|" filled-regexes)))) - (if (null regexes) - "" - (dumb-jump-concat-command cmd exclude-args "--" regex-args (shell-quote-argument proj))))) - -(defun dumb-jump-generate-git-grep-command (look-for - cur-file proj - regexes lang - exclude-paths) - "Return the git grep command to search for LOOK-FOR in the PROJ directory. -The arguments are: -- LOOK-FOR: string: the searched text -- CUR-FILE: string: current file name. Used to check the file extension and - restrict search to file extensions of the matching LANG. -- PROJ: string: project root path. -- REGEXES: list of strings: each string is a dumb-jump generic regular - expression. -- LANG: string: handled language. -- EXCLUDE_PATHS:list of strings: directories to exclude from search." - (let* ((filled-regexes (dumb-jump-populate-regexes look-for regexes 'git-grep)) - (ggtypes (when (file-name-extension cur-file) - (dumb-jump-get-git-grep-type-by-language lang))) - (cmd (concat dumb-jump-git-grep-cmd - " --color=never --line-number" - (if (member lang dumb-jump--case-insensitive-languages) - " --ignore-case" - "") - (when dumb-jump-git-grep-search-untracked - " --untracked") - (unless (string-blank-p dumb-jump-git-grep-search-args) - (concat " " dumb-jump-git-grep-search-args)) - " -E")) - (fileexps (dumb-jump--join " " - (or - (mapcar (lambda (it) - (shell-quote-argument - (format "%s/*.%s" proj it))) - ggtypes) - '(":/")))) - (exclude-args (dumb-jump--join " " - (mapcar (lambda (it) - (shell-quote-argument - (concat ":(exclude)" it))) - exclude-paths))) - (regex-args (shell-quote-argument (dumb-jump--join "|" filled-regexes)))) - (if (null regexes) - "" - (dumb-jump-concat-command cmd regex-args "--" fileexps exclude-args)))) - -(defun dumb-jump-generate-grep-command (look-for - cur-file proj - regexes lang - exclude-paths) - "Return the grep command to search for LOOK-FOR in PROJ directory. -The arguments are: -- LOOK-FOR: string: the searched item. -- CUR-FILE: string: current file name. Used to check if it's compressed. -- PROJ: string: project root path. -- REGEXES: list of strings: each string is a dumb-jump generic regular - expression. -- LANG: string: handled language. -- EXCLUDE-PATHS: list of strings: directories to exclude from search." - (let* ((filled-regexes - (mapcar (lambda (it) (shell-quote-argument it)) - (dumb-jump-populate-regexes look-for regexes 'grep))) - (cmd (concat - (if (eq system-type 'windows-nt) - "" - (concat dumb-jump-grep-prefix " ")) - (if (string-suffix-p ".gz" cur-file) - dumb-jump-zgrep-cmd - dumb-jump-grep-cmd))) - (case-args (if (member lang dumb-jump--case-insensitive-languages) - " --ignore-case" - "")) - (proj-dir (file-name-as-directory proj)) - (exclude-args (dumb-jump-arg-joiner - "--exclude-dir" - (mapcar - (lambda (it) - (dumb-jump--replace proj-dir "" it)) - exclude-paths))) - (include-args (dumb-jump-get-ext-includes lang)) - (regex-args (dumb-jump-arg-joiner "-e" filled-regexes))) - (if (null regexes) - "" - (dumb-jump-concat-command cmd dumb-jump-grep-args - case-args exclude-args - include-args regex-args (shell-quote-argument proj))))) - -(defun dumb-jump-generate-gnu-grep-command (look-for - cur-file proj - regexes lang - _exclude-paths) - "Return the GNU grep command to search for LOOK-FOR in PROJ directory. -The arguments are: -- LOOK-FOR: string: the searched item. -- CUR-FILE: string: current file name. Used to check if it's compressed. -- PROJ: string: project root path. -- REGEXES: list of strings: each string is a dumb-jump generic regular - expression. -- LANG: string: handled language. -- EXCLUDE-PATHS: list of strings: directories to exclude from search." - (let* ((filled-regexes - (mapcar (lambda (it) (shell-quote-argument it)) - (dumb-jump-populate-regexes look-for regexes 'gnu-grep))) - (cmd (concat - (if (eq system-type 'windows-nt) - "" - (concat dumb-jump-grep-prefix " ")) - (if (string-suffix-p ".gz" cur-file) - dumb-jump-zgrep-cmd - dumb-jump-grep-cmd))) - (case-args (if (member lang dumb-jump--case-insensitive-languages) - " --ignore-case" - "")) - ;; TODO: GNU grep doesn't support these, so skip them - (exclude-args "") - (include-args "") - (regex-args (dumb-jump-arg-joiner "-e" filled-regexes))) - (if (null regexes) - "" - (dumb-jump-concat-command cmd dumb-jump-gnu-grep-args - case-args exclude-args - include-args regex-args (shell-quote-argument proj))))) - -;; --------------------------------------------------------------------------- - -(defun dumb-jump-concat-command (&rest parts) - "Concat the PARTS of a command if each part has a length." - (let* ((normalized-parts (mapcar (lambda (it) (dumb-jump--trim (or it ""))) parts)) - (non-empty-parts (seq-filter (lambda (it) (> (length it) 0)) normalized-parts))) - (dumb-jump--join " " non-empty-parts))) - -(defun dumb-jump-get-file-exts-by-language (language) - "Return list of file extensions for a LANGUAGE." - (mapcar (lambda (it) (plist-get it :ext)) - (seq-filter (lambda (it) (string= (plist-get it :language) language)) - dumb-jump-language-file-exts))) - -(defun dumb-jump-get-ag-type-by-language (language) - "Return list of ag type argument for a LANGUAGE." - (seq-uniq (mapcar (lambda (it) (plist-get it :agtype)) - (seq-filter (lambda (it) - (and - (plist-get it :agtype) - (string= (plist-get it :language) language))) - dumb-jump-language-file-exts)))) - -(defun dumb-jump-get-rg-type-by-language (language) - "Return list of rg type argument for a LANGUAGE." - (seq-uniq (mapcar (lambda (it) (plist-get it :rgtype)) - (seq-filter (lambda (it) - (and - (plist-get it :rgtype) - (string= (plist-get it :language) language))) - dumb-jump-language-file-exts)))) - -(defun dumb-jump-get-rg-nontype-exts-by-language (language) - "Return list of file extensions for a LANGUAGE that have no rgtype. -These extensions need to be explicitly added as glob patterns since -they are not covered by ripgrep's built-in type definitions." - (seq-uniq (mapcar (lambda (it) (plist-get it :ext)) - (seq-filter (lambda (it) - (and - (plist-get it :ext) - (null (plist-get it :rgtype)) - (string= (plist-get it :language) language))) - dumb-jump-language-file-exts)))) - -(defun dumb-jump-get-git-grep-type-by-language (language) - "Return list of git grep type argument for a LANGUAGE." - (seq-uniq (mapcar (lambda (it) (plist-get it :ext)) - (seq-filter (lambda (it) - (and - (plist-get it :ext) - (string= (plist-get it :language) language))) - dumb-jump-language-file-exts)))) - -(defun dumb-jump-get-rules-by-language (language searcher) - "Return a list of rules for the LANGUAGE by SEARCHER." - (let* ((searcher-str (cond ((eq 'git-grep searcher) "git-grep") - ((eq 'rg searcher) "rg") - ((eq 'ag searcher) "ag") - ((eq 'git-grep-plus-ag searcher) "ag") - (t "grep"))) - (results (seq-filter (lambda (it) - (and - (string= (plist-get it ':language) language) - (member searcher-str (plist-get it ':supports)))) - dumb-jump-find-rules))) - (if dumb-jump-functions-only - (seq-filter (lambda (it) (string= (plist-get it ':type) "function")) results) - results))) - -;;;###autoload -(define-minor-mode dumb-jump-local-mode - "Buffer-local minor mode for jumping to variable and function definitions. -Use this to selectively enable dumb-jump in specific major modes, e.g.: - (add-hook \\='python-mode-hook #\\='dumb-jump-local-mode) -For enabling globally, use `dumb-jump-mode' instead." - :global nil - :keymap dumb-jump-mode-map) - -;;;###autoload -(define-minor-mode dumb-jump-mode - "Minor mode for jumping to variable and function definitions." - ;; Note: independent of the Emacs xref interface. - :global t - :keymap dumb-jump-mode-map) - - -;; ----------------------------------------------------------------------------- -;;; Xref Backend - -(unless dumb-jump-disable-obsolete-warnings - (dolist (obsolete - '(dumb-jump-mode - dumb-jump-go - dumb-jump-go-prefer-external-other-window - dumb-jump-go-prompt - dumb-jump-quick-look - dumb-jump-go-other-window - dumb-jump-go-current-window - dumb-jump-go-prefer-external)) - (make-obsolete - obsolete - (format "`%s' has been obsoleted by the xref interface." - obsolete) - "2020-06-26")) - (make-obsolete 'dumb-jump-back - "`dumb-jump-back' has been obsoleted by `xref-pop-marker-stack'." - "2020-06-26")) - -(cl-defmethod xref-backend-identifier-at-point ((_backend (eql dumb-jump))) - (let ((bounds (bounds-of-thing-at-point 'symbol))) - (and bounds (let* ((ident (dumb-jump-get-point-symbol)) - (start (car bounds)) - (col (- start (line-beginning-position))) - (line (dumb-jump-get-point-line)) - (ctx (dumb-jump-get-point-context line ident col))) - (propertize ident :dumb-jump-ctx ctx))))) - -(cl-defmethod xref-backend-definitions ((_backend (eql dumb-jump)) - entered-name) - (let* ((info (dumb-jump-get-results entered-name)) - (results (plist-get info :results)) - (look-for (or entered-name (plist-get info :symbol))) - (proj-root (plist-get info :root)) - (issue (plist-get info :issue)) - (lang (plist-get info :lang)) - (processed (dumb-jump-process-results - results - (plist-get info :file) - proj-root - (plist-get info :ctx-type) - look-for - nil - nil - lang)) - (results (plist-get processed :results)) - (do-var-jump (plist-get processed :do-var-jump)) - (var-to-jump (plist-get processed :var-to-jump)) - (match-cur-file-front (plist-get processed :match-cur-file-front))) - - (dumb-jump-debug-message - look-for - (plist-get info :ctx-type) - var-to-jump - (pp-to-string match-cur-file-front) - (pp-to-string results) - match-cur-file-front - proj-root - (plist-get info :file)) - (cond ((eq issue 'nogrep) - (dumb-jump-message "Please install ag, rg, git grep or grep!")) - ((eq issue 'nosymbol) - (dumb-jump-message "No symbol under point.")) - ((string-suffix-p " file" lang) - (dumb-jump-message "Could not find rules for '%s'." lang)) - ((= (length results) 0) - (dumb-jump-message "'%s' %s %s declaration not found." - look-for - (if (string-blank-p (or lang "")) - "with unknown language so" - lang) - (plist-get info :ctx-type))) - (t (mapcar (lambda (res) - (with-no-warnings - (xref-make - (plist-get res :context) - (xref-make-file-location - (let* ((path (plist-get res :path)) - (remote-prefix (file-remote-p default-directory))) - (if remote-prefix - (if (file-name-absolute-p path) - (concat remote-prefix path) - (concat default-directory path)) - (expand-file-name path))) - (plist-get res :line) - 0)))) - (if do-var-jump - (list var-to-jump) - match-cur-file-front)))))) - -(cl-defmethod xref-backend-references ((_backend (eql dumb-jump)) - entered-name) - (let* ((dumb-jump--search-mode 'references) - (info (dumb-jump-get-results entered-name)) - (results (plist-get info :results)) - (look-for (or entered-name (plist-get info :symbol))) - (proj-root (plist-get info :root)) - (issue (plist-get info :issue)) - (lang (plist-get info :lang)) - (processed (dumb-jump-process-results - results - (plist-get info :file) - proj-root - (plist-get info :ctx-type) - look-for - nil - nil - lang)) - (results (plist-get processed :results)) - (match-cur-file-front (plist-get processed :match-cur-file-front))) - - (cond ((eq issue 'nogrep) - (dumb-jump-message "Please install ag, rg, git grep or grep!")) - ((eq issue 'nosymbol) - (dumb-jump-message "No symbol under point.")) - ((string-suffix-p " file" lang) - (dumb-jump-message "Could not find rules for '%s'." lang)) - ((= (length results) 0) - (dumb-jump-message "'%s' %s references not found." - look-for - (if (string-blank-p (or lang "")) - "with unknown language so" - lang))) - (t (mapcar (lambda (res) - (with-no-warnings - (xref-make - (plist-get res :context) - (xref-make-file-location - (let* ((path (plist-get res :path)) - (remote-prefix (file-remote-p default-directory))) - (if remote-prefix - (if (file-name-absolute-p path) - (concat remote-prefix path) - (concat default-directory path)) - (expand-file-name path))) - (plist-get res :line) - 0)))) - match-cur-file-front))))) - -(cl-defmethod xref-backend-apropos ((_backend (eql dumb-jump)) pattern) - (xref-backend-definitions 'dumb-jump pattern)) - -(cl-defmethod xref-backend-identifier-completion-table - ((_backend (eql dumb-jump))) - nil) - -;;;###autoload -(defun dumb-jump-xref-activate () - "Function to activate xref backend. -Add this function to `xref-backend-functions' to dumb jump to be -activated, whenever it finds a project. It is recommended to add -it to the end, so that it only gets activated when no better -option is found." - (and (dumb-jump-get-project-root default-directory) - 'dumb-jump)) - -(provide 'dumb-jump) -;;; dumb-jump.el ends here |