Emacs: 如何提高编程速度-Emacs高手教授轻松学习所有编辑器和IDE的秘诀

// 将键绑定放在此文件中以覆盖默认值
[
    {
        "key": "F12",
        "command": "workbench.action.togglePanel",
    },
    {
        "key": "Ctrl+]",
        "command": "editor.action.goToTypeDefinition",
    },
    {
        "key": "Ctrl+T",
        "command": "workbench.action.navigateBack",
    },
 {
  "key": "Ctrl+F12",
  "command": "workbench.action.toggleMaximizedPanel"
}
]

# :help tagsrch.txt
CTRL-]：跳到类型定义
CTRL-t：跳回

# :help pattern.txt
gd       # 跳转到定义 go to declaration

# :help motion.txt
CTRL-O 带您跳转回较旧的位置。可跳到上一个文件搜索的旧搜索位置，可多次操作
CTRL-I 则带您到较新的位置。可跳到下一个文件搜索的新搜索位置，可多次操作

{
  "vim.easymotion": true,
  "vim.sneak": true,
  "vim.visualstar": true,  // 开启 * # 搜索
  "vim.ignorecase": false,
  "vim.useSystemClipboard": true,
  "vim.useCtrlKeys": true,
  "vim.hlsearch": true,
  "vim.insertModeKeyBindings": [
    {
      "before": ["k","j"], //  插入模式下 按 k j 代表 ecs 退出到普通模式
      "after": ["<Esc>"]
    }
  ],
  "vim.leader": ",",
  "vim.visualModeKeyBindingsNonRecursive": [
    {
      "before": ["v"],  // 扩大选中的区域
      "commands": ["editor.action.smartSelect.expand"]
    },
    {
      "before": ["%"],  // 优化%符号跳转功能，需安装插件 matchit
      "commands": ["extension.matchitJumpItems"]
    },
    {
      "before": ["<leader>","x", "x"],  // 扩大选中的区域
      "commands": ["editor.action.smartSelect.expand"]
    },
    {
      "before": ["<leader>","z", "z"], // 缩选中的区域
      "commands": ["editor.action.smartSelect.shrink"]
    },
    {
      "before": ["<leader>","c", "i"], // 注释行，快捷键命名来自于 vim 插件 nerd-commenter
      "commands": ["editor.action.commentLine"]
    },
    {
      "before": ["<leader", "a", "a"], // ctrl-c 复制
      "commands": ["editor.action.clipboardCopyAction"]
    },
    {
      "before": ["<leader>","q", "q"], // 项目中多个文件文本查找
      "commands": ["workbench.action.findInFiles"]
    },
    {
      "before": ["<leader>","s", "s"],  // 当前文件搜索
      "commands": ["actions.find"]
    }
  ],
  "vim.normalModeKeyBindingsNonRecursive": [
    {
      "before": ["<leader>","r", "v"],
      "commands": ["editor.action.rename"]
    },
    {
      "before": ["<leader>","q", "q"], // 项目中查找替换多个文件
      "commands": ["workbench.action.findInFiles"]
    },
    {
      "before": ["<leader>","f", "p"],  // 拷贝当前文件路径
      "commands": ["workbench.action.files.copyPathOfActiveFile"]
    },
    {
      "before": ["<leader>","f", "n"],
      "commands": ["copyRelativeFilePath"]
    },
    {
      "before": ["<leader>","t", "p"], // 打开下拉菜单
      "commands": ["workbench.action.togglePanel"]
    },
    {
      "before": ["<leader>","x", "m"], // 显示命令面板
      "commands": ["workbench.action.showCommands"]
    },
    {
      "before": ["<leader>","c", "i"], // 注释行，快捷键命名来自于 vim 插件 nerd-commenter
      "commands": ["editor.action.commentLine"]
    },
    {
      "before": ["<leader>","x", "x"], // 扩大选中的区域
      "commands": ["editor.action.smartSelect.expand"]
    },
    {
      "before": ["<leader>","z", "z"], // 缩选中的区域
      "commands": ["editor.action.smartSelect.shrink"]
    },
    {
      "before": ["<leader>","t", "a"], // 显示活动栏
      "commands": ["workbench.action.toggleActivityBarVisibility"]
    },
    {
      "before": ["<leader>","t", "b"], // 显示主侧边栏
      "commands": ["workbench.action.toggleSidebarVisibility"]
    },
    {
      "before": ["<leader>","x", "s"], // 保存文件
      "commands": ["workbench.action.files.save"]
    },
    {
      "before": ["<leader>","s", "s"], // 当前文件搜索
      "commands": ["actions.find"]
    },
    {
      "before": ["%"], // 优化%符号跳转功能，需安装插件 matchit
      "commands": ["extension.matchitJumpItems"]
    },
    {
      "before": ["<leader>","s", "i"],
      "commands": ["extension.matchitSelectItems"]
    },
    {
      "before": ["<leader>","d", "i"],
      "commands": ["extension.matchitDeleteItems"]
    },
    {
      "before": ["<leader>","x", "f"],  // 打开文件
      "commands": ["workbench.action.files.openFile"]
    },
    {
      "before": ["<leader>", "x", "k"],
      "commands": ["workbench.action.closeActiveEditor"]
    },
    {
      "before": ["<leader>","r", "r"],  // 最近访问文件
      "commands": ["workbench.action.openRecent"]
    },
    {
      "before": ["<leader>","k", "k"], // 打开项目中任意文件
      "commands": ["workbench.action.quickOpen"]
    },
    {
      "before": ["<leader>","i", "i"], // 转到编辑器中的符号
      "commands": ["workbench.action.gotoSymbol"]
    },
    {
      "before": ["<leader>","x", "1"], // 仅一个窗口
      "commands": ["workbench.action.editorLayoutSingle"]
    },
    {
      "before": ["<leader>","x", "3"], // 向右垂直分屏
      "commands": ["workbench.action.splitEditorRight"]
    },
    {
      "before": ["<leader>","x", "2"], // 向下水平分屏
      "commands": ["workbench.action.splitEditorDown"]
    },
    {
      "before": ["<leader>","x", "4"], // 分 2*2 窗口
      "commands": ["workbench.action.editorLayoutTwoByTwoGrid"]
    },
    {
      "before": ["<leader>","x", "0"], // 关闭分组
      "commands": ["workbench.action.closeGroup"]
    },
    {
      "before": ["<leader>","x", "z"], // 打开终端
      "commands": ["workbench.action.terminal.focus"]
    },
    {
      "before": ["<leader>","f", "f"], // 禅模式
      "commands": ["workbench.action.toggleZenMode"]
    },
    {
      "before": ["<leader>","w", "h"], // 移动到左窗口
      "after": ["<C-w>", "h"]
    },
    {
      "before": ["<leader>","w", "j"],
      "after": ["<C-w>", "j"]
    },
    {
      "before": ["<leader>","w", "k"],
      "after": ["<C-w>", "k"]
    },
    {
      "before": ["<leader>","w", "l"],
      "after": ["<C-w>", "l"]
    },
    {
      "before": ["<leader>","w", "q"],
      "after": [":wq"],
    }
  ],
  "vim.handleKeys":{
    "<C-a>": false,
  },
  "zenMode.centerLayout": false,
  "window.zoomLevel": 1,
  "editor.minimap.enabled": false,
  "search.exclude": {
    "**/.git": true,
    "**/*.bundle.js": true,
    "**/bin-packages": true,
    "**/frontend-dist": true,
    "**/npm-packages-offline-cache": true
  },
  "search.useGlobalIgnoreFiles": true,
  "search.location": "panel",  // 弃用，搜索下移，新版本手动拖拽方式
  "workbench.activityBar.visible": false,
  "files.autoSave": "afterDelay",
  "workbench.colorTheme": "Solarized Dark",
  "workbench.statusBar.visible": true,
  "editor.renderWhitespace": "none",
  "editor.renderControlCharacters": false,
  "window.titleBarStyle": "native",
  "editor.renderLineHighlight": "none",
  "extensions.ignoreRecommendations": true,
  "editor.occurrencesHighlight": false
}

# 设置leader键为 , 逗号
 "vim.leader": ","

# 插入模式下 按 k j 代表 ecs 退出到普通模式
  "vim.insertModeKeyBindings": [
    {
      "before": ["k","j"],
      "after": ["<Esc>"]
    }
  ],

# 在视图模式中使用
  "vim.visualModeKeyBindingsNonRecursive": [
...
   ]
# 在普通模式中使用
 "vim.normalModeKeyBindingsNonRecursive": [
 ...
   ]

# 设置leader键为 , 逗号
# 插入模式下 按 k j 代表 ecs 退出到普通模式

# 文件操作 仅普通模式
最近访问文件：,rr 
打开文件：,xf 和 emacs 中 `C-x C-f` 类似
保存文件：,xs 和emacs中`c-x c-s`相似

# 编辑操作
undo/redo：vim 操作 uU/C-r。 . 点号重复操作，:e! 文档还原到最原始状态
剪贴：vim 中 x。d 也是删除
复制：,aa 选中复制。仅视图模式。vim 中 yy 复制当前行；选中 "+y 从 vim 拷贝到系统剪切板，"+p 系统到 vim
粘贴：vim 中 p
查找字符：,ss 。vim 中 / 。视图和普通模式下
替换：: :%s*(wor)(ld)*$1=$2*g  ，原生 vim 为 :%s*\(wor\)\(ld\)*\1=\2*g
注释：,ci 。结合 vim 注释3行：`V3j` + `,ci`；结合 emacs 注释3行：`C-u 4` + `,ci` 。视图和普通模式下
多文件查找：,qq 。 视图和普通模式下.

# 选择操作
全选：C-a
扩大选择区：按 v 或者 ,xx 。emacs 中扩大选择区: ,xx  再按x扩大。缩小选区: z。恢复：-1 。 视图模式和普通模式
缩小选择区：,zz 仅视图模式。emacs  支持 key map 更方便，扩大选择区: ,xx  再按x扩大， 缩小选区: z， 恢复：0
复制行：vim 中 `yy  p`
多光标操作：使用 vim 代替
- 列编辑：ctrl + v 向下移动， 大写 I 输入
- text object文件对象：
vit 选中tag内的
vat 选中包含tag
vi{ 选中括号内的
va{ 选中括号内的，包含括号
# 安装 vim-surround 插件后
cs`" 替换`为“  * vs code 中生效
ysw"  单词加绰号。 vs code 中生效。

# 视图下子窗口操作
命令面板：,xm 普通模式下
禅模式：,ff 普通模式
,xm：leader键，命令面板，仅普通模式
,ff：leader键，禅模式，仅普通模式
分屏：
,x1：leader键，仅保留当前子窗口，仅普通模式
,x3：leader键，右竖分屏，仅普通模式
,x2：leader键，水平分割，仅普通模式
,x4：leader键，开4个屏，仅普通模式
,x0：leader键，关闭当前屏，仅普通模式
- vim 分屏:
Ctrl+w,s：水平分割，上下分屏。或者:sp
Ctrl+w,v：垂直分割，左右分屏，或者:vs

:close 关闭当前窗口
:only 关闭除当前窗口以外的所有窗口

Ctrl+w c   关闭分屏  关闭当前窗口
Ctrl+w，方向键 : 窗口间切换

<C-w>w 在窗口循环切换。如<C-w><C-w><C-w><C-w>
<C-w>h 切换到左边的窗口
<C-w>j 切换到下边的窗口
<C-w>k 切换到上边的窗口
<C-w>l 切换到右边的窗口
移动
<C-w>L 左边窗口移动到右边
<C-w>H 右边窗口移动到左边

# go
- 跳转操作
C-t：回退。和 vim emacs 保持兼容
C-]：转到类定义
,kk：搜索并打开项目中任意文件，仅普通模式

- 上次搜索位置（vim）
C-o 带您跳转回较旧的位置。可跳到上一个文件搜索的旧搜索位置，可多次操作
C-i 则带您到较新的位置。可跳到下一个文件搜索的新搜索位置，可多次操作

- 定位及文件状态（vim）
G 最后一行
1G, gg 第一行
4gg, :4  第4行
C-g：显示当前编辑文件中当前光标所在行位置以及文件状态信息

%：配对的符号间跳转，光标放在当前标记下(、)、[、]、{、}

- 代码自动完成
C-n：vim 中完成单词，ctrl + n 向下选，ctrl + p 向上选
C-x C-l：完成行

- 可选的
  - 跳转声明（可选）
    ,ii：leader 键，转到编辑器的符号。vim 中用 gd，C-o 回到原位置

  - 打开当前光标下的文件（可选）
    gf：vim 中打开当前光标下的文件，C-o 回到原位置

  - 在当前文件搜索文本（可选）
    `*/#`：* 向下标记当前光标单词，# 相反。关闭高亮用 :set nohls

-  其它
kj：在插入模式下退回到普通模式
,xk：leader键，关闭当前编辑
,sp：leader键，回报社会

# window
git clone https://github.com/NeoVintageous/NeoVintageous.git "%APPDATA%\Sublime Text 3/Packages/NeoVintageous"

" Type :help nv for help.
" @see http://docs.sublimetext.info/en/latest/reference/api.html for all commands
let mapleader= ","

noremap <leader>xm :ShowOverlay overlay=command_palette<CR> " 命令面板
noremap <leader>ci :ToggleComment<CR>
noremap <leader>xs :SaveAll<CR>
noremap <leader>aa :Copy<CR><ESC>
noremap <leader>zz :Paste<CR>
noremap <leader>yy :PasteFromHistory<CR>  " 从多个剪贴板中粘贴
noremap <leader>qq :ShowPanel panel=find_in_files<CR> " 搜索
noremap <leader>ss :ShowOverlay overlay=goto text=*<CR> " 当前文件搜索
noremap <leader>kk :ShowOverlay overlay=goto show_files=true<CR>  " 找文件
noremap <leader>ii :ShowOverlay overlay=goto text=@<CR> " 当前文件找出符号
noremap <leader>x1 :SetLayout cols=1 rows=1<CR> " 只有一个子窗口
noremap <leader>x2 :sp<CR>
noremap <leader>x3 :vs<CR>

[
  { "caption": "NeoVintageous: Toggle", "command": "toggle_neo_vintageous" }
]

import sublime
import sublime_plugin

class ToggleNeoVintageous(sublime_plugin.WindowCommand):
    def run(self):
        setts = sublime.load_settings('Preferences.sublime-settings')
        ignored = setts.get('ignored_packages')

        if 'NeoVintageous' in ignored:
            ignored.remove('NeoVintageous')
        else:
            ignored.append('NeoVintageous')

        setts.set('ignored_packages', ignored)
        sublime.save_settings('Preferences.sublime-settings')

IdeaVim插件安装配置：
(1) 在File->Setting -> Plugins -> Browse repositories中查找IdeaVim插件安装即可。
(2) 重启  IntelliJ IDEA

# 将配置文件拷贝到
~/.ideavimrc

,qq：多文件查找字符。这里用的 grep，没用 ag
C-c C-o：进入 ivy-occur 中。如果想排除某文件可输入正则 !code.js
C-x C-q：变成可编辑的
dd：排除不需要处理的行（可选）
,rb：查找替换。即 :'<,'>s/\<(选中的字符\)\>/要替换成的字符/g  。  这里用的是自己写的代码。
C-c C-c：完成

# 删除行
在 dd 换成 C-c C-d 删除行，此为 wgrep 插件源代码有写

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

sudo apt install git # 安装 tags, git等

;; replace-regexp-in-string
;; mactch-string string-match

;;
;; replace-regexp-in-string
;; 给定一个字符串搜索某个模式，然后把它替换掉
(setq str "abc1339def")
(setq a (replace-regexp-in-string "[0-9]+" "" str)) ;; "abcdef"


;; string-match 正则表达式是否匹配字符串
;; match-string 把上个匹配返回的
;; 字符串的 2 个斜杠会解释为 \(\) 类似于 grep 中的 group 组定义
(when (string-match "[a-z]*\\([0-9]*\\)[a-z]*" str)
  (message (match-string 1 str)))

(defun hello ()
  (interactive)
  (message "hello world"))

> find . \( -path "*/.git" -o -path "*/.svn" \) -a -prune -o -print -type f -name "*.*"
.
./nvim.appimage
./.DS_Store
./etcd.config.yml.swp
./portable-ruby-2.6.8.arm64_big_sur.bottle.tar.gz
./myssh.sh
./AWSCLIV2.pkg
./my-find-file.el
./down
./down/.DS_Store
# 换成可以解决 find . \( -path "*/.git" -o -path "*/.svn" \) -a -prune -o  -type f -name "*.*" -print

(require 'ivy) ; optional
(defun my-find-file ()
  (interactive)
  (let* ( (cmd "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -print -type f -name \"*.*\"")
          (output (shell-command-to-string cmd))
          (lines (cdr (split-string output "[\n\r]+"))))
    (setq selected-line     (ivy-read "Find file: " lines))
    (when (and selected-line (file-exists-p selected-line))
      (find-file selected-line))
    ))
;; M-x eval-buffer, M-x my-find-file
10   Find file:
./nvim.appimage
./.DS_Store
./etcd.config.yml.swp
./portable-ruby-2.6.8.arm64_big_sur.bottle.tar.gz
./myssh.sh
./AWSCLIV2.pkg
./a.txt
./my-find-file.el
./down

> find . -name "*.*" |wc -l
   73312
> cloc ./
   79447 text files.
   78892 unique files.
   11210 files ignored.

github.com/AlDanial/cloc v 1.90  T=75.61 s (902.9 files/s, 447811.7 lines/s)
---------------------------------------------------------------------------------------
Language                             files          blank        comment           code
---------------------------------------------------------------------------------------
C                                    32314        3276392        2578741       16882894
C/C++ Header                         23460         703974        1338664        6929246
reStructuredText                      3300         160571          64369         438061
JSON                                   508              2              0         360081
YAML                                  3151          57690          14530         265588
Assembly                              1328          47811         101201         229944
Bourne Shell                           900          27555          18983         107930
make                                  2803          10866          11819          49930
SVG                                     74             90           1171          48177
Perl                                    66           7383           5033          36556
Python                                 157           6813           6354          33942
Rust                                    37            948           5454           5539
yacc                                     9            700            409           4914
PO File                                  6            948           1088           3733
lex                                      9            346            309           2111
C++                                     10            373            138           2022
Bourne Again Shell                      56            392            322           1603
awk                                     13            217            157           1323
Glade                                    1             58              0            603
CSV                                     10             73              0            597
NAnt script                              2            154              0            545
Cucumber                                 1             34             58            196
TeX                                      1              6             74            156
TNSDL                                    2             33              0            140
Windows Module Definition                2             15              0            110
CSS                                      3             38             49            104
m4                                       1             15              1             95
Clojure                                 31              0              0             73
XSLT                                     5             13             26             61
MATLAB                                   1             17             37             35
vim script                               1              3             12             27
Markdown                                 1              8              0             25
Ruby                                     1              4              0             25
INI                                      1              1              0              6
sed                                      1              2              5              5
TOML                                     1              1              9              2
---------------------------------------------------------------------------------------
SUM:                                 68267        4303546        4149013       25406399
---------------------------------------------------------------------------------------

(require 'ivy) ; optional
(defun my-find-file ()
  (interactive)
  (let* ( (cmd "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -print -type f -name \"*.*\"")
          (default-directory "~/tmp/linux-master")
          (output (shell-command-to-string cmd))
          (lines (cdr (split-string output "[\n\r]+")))
          selected-line)
    (setq selected-line     (ivy-read (format "Find file in %s: " default-directory) lines))
    (when (and selected-line (file-exists-p selected-line))
      (find-file selected-line))
    ))
;; M-x eval-buffer, 在 linux-master 任意子目录执行：M-x my-find-file
;; output
84629 Find file in ~/tmp/linux-master:
./init
./init/do_mounts_rd.c
./init/do_mounts.c
./init/do_mounts_initrd.c

(require 'ivy) ; optional
(defun my-find-file ()
  (interactive)
  (let* ( (cmd "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -print -type f -name \"*.*\"")
          (default-directory (locate-dominating-file default-directory ".git"))
          (output (shell-command-to-string cmd))
          (lines (cdr (split-string output "[\n\r]+")))
          slected-line)
    (setq selected-line     (ivy-read (format "Find file in %s: " default-directory) lines))
    (when (and selected-line (file-exists-p selected-line))
      (find-file selected-line))
    ))

;; M-x eval-buffer, 在 linux-master 任意子目录执行：M-x my-find-file

(require 'ivy) ; optional
(defun my-find-file-internal (directory)
  "Find file in DIRECTORY"
  (let* ( (cmd "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -print -type f -name \"*.*\"")
          (default-directory directory)
          (output (shell-command-to-string cmd))
          (lines (cdr (split-string output "[\n\r]+")))
          selected-line)
    (setq selected-line     (ivy-read (format "Find file in %s: " default-directory)
                                      lines))
    (when (and selected-line (file-exists-p selected-line))
      (find-file selected-line))
    )
  )
(defun my-find-file-in-project ()
  "Find file project root directory"
  (interactive)
  (my-find-file-internal (locate-dominating-file default-directory ".git")))

(defun my-find-file ()
  "Find file in current directory"
  (interactive)
  (my-find-file-internal default-directory))

;; M-x eval-buffer
;; 在 linux-master 任意子目录执行：M-x my-find-file   ：M-x my-find-file-in-project

(defun my-find-file (&optional level)
  "Find file in current directory"
  (interactive "P")
  (message "leve=%s" level)
  (my-find-file-internal default-directory))

;; M-x eval-expression (my-find-file 1)  ;; level=1
;; 或者 C-u 1 M-x my-find-file ;; level=1
;; 或者 C-u  空 M-x my-find-file  ;; level=nil

(defun my-find-file (&optional level)
  "Find file in current directory"
  (interactive "P")
  (unless level (setq level 0))
  ;; default-directory
  (let* ((parent-directory default-directory)
         (i 0))
    (while (< i level)
      ;; directory-file-name
      ;; file-name-directory
      (setq parent-directory
            (file-name-directory (directory-file-name parent-directory)))
      (setq i (+ i 1)))
   ;; (my-find-file-internal parent-directory)
    (message "parent-derectory=%s" parent-directory)
   ))
;; M-x eval-buffer
;; M-x my-find-file ;;output parent-derectory=/Users/7tq6lr/Documents/wd/pfg/
;; C-u 2 M-x my-find-file ;;output parent-derectory=/Users/7tq6lr/Documents/

(my-comma-leader-def
 "xf" 'my-find-file
 )

(require 'ivy) ; optional
(defun my-find-file-internal (directory)
  "Find file in DIRECTORY"
  (let* ( (cmd "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -print -type f -name \"*.*\"")
          (default-directory directory)
          (output (shell-command-to-string cmd))
          (lines (cdr (split-string output "[\n\r]+")))
          selected-line)
    (setq selected-line     (ivy-read (format "Find file in %s: " default-directory)
                                      lines))
    (when (and selected-line (file-exists-p selected-line))
      (find-file selected-line))))

(defun my-find-file-in-project ()
  "Find file project root directory"
  (interactive)
  (my-find-file-internal (locate-dominating-file default-directory ".git")))

(defun my-find-file (&optional level)
  "Find file in current directory"
  (interactive "P")
  (unless level (setq level 0))
  ;; default-directory
  (let* ((parent-directory default-directory)
         (i 0))
    (while (< i level)
      ;; directory-file-name
      ;; file-name-directory
      (setq parent-directory
            (file-name-directory (directory-file-name parent-directory)))
      (setq i (+ i 1)))
    ;;2,xf
    (my-find-file-internal parent-directory)))
;; M-x eval-buffer
;; 1,xf
;; 2,xf

find . \( -path "*/.git" -o -path "*/.svn"  \) -prune -o -type f -iname "*test*" -print

(read-string PROMPT &optional INITIAL-INPUT HISTORY DEFAULT-VALUE INHERIT-INPUT-METHOD)
在 minibuffer 中读取用户输入并返回

(require 'ivy) ; optional
(defun my-find-file-internal (directory)
  "Find file in DIRECTORY"
  (let* ((keyword (read-string "Please input keyword: ")))
    (when (and keyword (not (string= keyword "")))
      (let* ( (cmd (format "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -type f -iname \"*%s*\" -print" keyword))
              (default-directory directory)
              (output (shell-command-to-string cmd))
              (lines (split-string output "[\n\r]+"))
              selected-line)
        (setq selected-line  (ivy-read (format "Find file in %s: " default-directory)
                                          lines))
        (when (and selected-line (file-exists-p selected-line))
          (find-file selected-line))))))

(defun my-find-file-in-project ()
  "Find file project root directory"
  (interactive)
  (my-find-file-internal (locate-dominating-file default-directory ".git")))

(defun my-find-file (&optional level)
  "Find file in current directory"
  (interactive "P")
  (unless level (setq level 0))
  ;; default-directory
  (let* ((parent-directory default-directory)
         (i 0))
    (while (< i level)
      ;; directory-file-name
      ;; file-name-directory
      (setq parent-directory
            (file-name-directory (directory-file-name parent-directory)))
      (setq i (+ i 1)))
    ;;2,xf
    (my-find-file-internal parent-directory)))
;; M-x eval-buffer
;; 1,xf
;; 2,xf

(defun my-file-internal (directory &optional grep-p)
  "Find file in DIRECTORY.
If GREP-P is t, grep files.
If GREP-P is nil, find files."
  (let* ((keyword (read-string "Please input keyword: ")))
    (when (and keyword (not (string= keyword "")))
      (let* ((find-cmd (format "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -type f -iname \"*%s*\" -print" keyword))
             (grep-cmd (format "grep --exclude-dir=\"*/.git\" --exclude-dir=\"*/.svn\"  -rns  \"%s\" ." keyword))
             (default-directory directory)
             (output (shell-command-to-string (if grep-p grep-cmd find-cmd)))
             (lines (split-string output "[\n\r]+"))
             (hint (if grep-p "Grep file in %s: " "Find file in %s: "))
             selected-line)
        (setq selected-line  (ivy-read (format hint default-directory)
                                          lines))
        (message "selected-line=%s" selected-line)
        ;; (when (and selected-line (file-exists-p selected-line))
        ;;   (find-file selected-line))
        ))))
;; M-x eval-buffer
;; M-x eval-expression (my-file-internal default-directory t)
;; output
19   Grep file in /Users/7tq6lr/Documents/wd/pfg/:
./KPI-2022.org:22:5. 压测（load test, spike test, soak Testcc)
./KPI-2022.html:306:<li>压测（load test, spike test, soak Testcc)<br /></li>

(defun my-file-internal (directory &optional grep-p)
  "Find file in DIRECTORY.
If GREP-P is t, grep files.
If GREP-P is nil, find files."
  (let* ((keyword (read-string "Please input keyword: ")))
    (when (and keyword (not (string= keyword "")))
      (let* ((find-cmd (format "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -type f -iname \"*%s*\" -print" keyword))
             (grep-cmd (format "grep --exclude-dir=\"*/.git\" --exclude-dir=\"*/.svn\"  -rns  \"%s\" ." keyword))
             (default-directory directory)
             (output (shell-command-to-string (if grep-p grep-cmd find-cmd)))
             (lines (split-string output "[\n\r]+"))
             (hint (if grep-p "Grep file in %s: " "Find file in %s: "))
             selected-line
             selected-file
             linenum)
        (setq selected-line  (ivy-read (format hint default-directory)
                                          lines))
        (cond
          (grep-p
           (when (string-match "\\(^[^:]*\\):\\([0-9]*\\):" selected-line)
             (setq selected-file (match-string 1 selected-line))
             (setq linenum (match-string 2 selected-line))
             (message "selected-file=%s linenum=%s" selected-file linenum)
             )
           )
          (t
           (setq selected-file selected-line)))
        ;; (when (and selected-line (file-exists-p selected-file))
        ;;   (find-file selected-file))
        ))))
;; M-x eval-buffer
;; M-x eval-expression (my-file-internal default-directory t)
;; output
selected-file=./KPI-2022.org linenum=22

(defun my-file-internal (directory &optional grep-p)
  "Find file in DIRECTORY.
If GREP-P is t, grep files.
If GREP-P is nil, find files."
  (let* ((keyword (read-string "Please input keyword: ")))
    (when (and keyword (not (string= keyword "")))
      (let* ((find-cmd (format "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -type f -iname \"*%s*\" -print" keyword))
             (grep-cmd (format "grep --exclude-dir=\"*/.git\" --exclude-dir=\"*/.svn\"  -rns  \"%s\" ." keyword))
             (default-directory directory)
             (output (shell-command-to-string (if grep-p grep-cmd find-cmd)))
             (lines (split-string output "[\n\r]+"))
             (hint (if grep-p "Grep file in %s: " "Find file in %s: "))
             selected-line
             selected-file
             linenum)
        (setq selected-line  (ivy-read (format hint default-directory)
                                          lines))
        (cond
          (grep-p
           (when (string-match "\\(^[^:]*\\):\\([0-9]*\\):" selected-line)
             (setq selected-file (match-string 1 selected-line))
             (setq linenum (match-string 2 selected-line))))
          (t
           (setq selected-file selected-line)))
        (when (and selected-line (file-exists-p selected-file))
          (find-file selected-file)
          (when grep-p
          (goto-char (point-min))
          (forward-line (1- (string-to-number linenum)))))
        ))))

(require 'ivy) ; optional
(defun my-file-internal (directory &optional grep-p)
  "Find file in DIRECTORY.
If GREP-P is t, grep files.
If GREP-P is nil, find files."
  (let* ((keyword (read-string "Please input keyword: ")))
    (when (and keyword (not (string= keyword "")))
      (let* ((find-cmd (format "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -type f -iname \"*%s*\" -print" keyword))
             (grep-cmd (format "grep --exclude-dir=\"*/.git\" --exclude-dir=\"*/.svn\"  -rns  \"%s\" ." keyword))
             (default-directory directory)
             (output (shell-command-to-string (if grep-p grep-cmd find-cmd)))
             (lines (split-string output "[\n\r]+"))
             (hint (if grep-p "Grep file in %s: " "Find file in %s: "))
             selected-line
             selected-file
             linenum)
        (setq selected-line  (ivy-read (format hint default-directory)
                                          lines))
        (cond
          (grep-p
           (when (string-match "\\(^[^:]*\\):\\([0-9]*\\):" selected-line)
             (setq selected-file (match-string 1 selected-line))
             (setq linenum (match-string 2 selected-line))))
          (t
           (setq selected-file selected-line)))
        (when (and selected-line (file-exists-p selected-file))
          (find-file selected-file)
          (when grep-p
          (goto-char (point-min))
          (forward-line (1- (string-to-number linenum)))))
        ))))

(defun my-search-text-in-project ()
  "Search text of files in project root directory."
  (interactive)
  (my-file-internal (locate-dominating-file default-directory ".git") t))

(defun my-search-text (&optional level)
  "Search text of files in current directory or LEVEL parent directory."
  (interactive "P")
  (unless level (setq level 0))
  ;; default-directory
  (let* ((parent-directory default-directory)
         (i 0))
    (while (< i level)
      ;; directory-file-name
      ;; file-name-directory
      (setq parent-directory
            (file-name-directory (directory-file-name parent-directory)))
      (setq i (+ i 1)))
    ;;2,xf
    (my-file-internal parent-directory t)))
;; M-x eval-buffer
;; M-x my-search-text-in-project
;; C-u 2 M-x my-search-text

(defun my-file-internal (directory &optional grep-p git-grep-p)
...
             (git-cmd-fmt (if git-grep-p "git grep -n \"%s\"" "grep --exclude-dir=\"*/.git\" --exclude-dir=\"*/.svn\"  -rns  \"%s\" ." ))
             (grep-cmd (format git-cmd-fmt keyword))
...

(require 'ivy) ; optional
(defun my-file-internal (directory &optional grep-p git-grep-p)
  "Find file in DIRECTORY.
If GREP-P is t, grep files.
If GREP-P is nil, find files."
  (let* ((keyword (read-string "Please input keyword: ")))
    (when (and keyword (not (string= keyword "")))
      (let* ((find-cmd (format "find . \\( -path \"*/.git\" -o -path \"*/.svn\"  \\) -prune -o -type f -iname \"*%s*\" -print" keyword))
             (git-cmd-fmt (if git-grep-p "git grep -n \"%s\"" "grep --exclude-dir=\"*/.git\" --exclude-dir=\"*/.svn\"  -rns  \"%s\" ." ))
             (grep-cmd (format git-cmd-fmt keyword))
             (default-directory directory)
             (output (shell-command-to-string (if grep-p grep-cmd find-cmd)))
             (lines (split-string output "[\n\r]+"))
             (hint (if grep-p "Grep file in %s: " "Find file in %s: "))
             selected-line
             selected-file
             linenum)
        (setq selected-line  (ivy-read (format hint default-directory)
                                          lines))
        (cond
          (grep-p
           (when (string-match "\\(^[^:]*\\):\\([0-9]*\\):" selected-line)
             (setq selected-file (match-string 1 selected-line))
             (setq linenum (match-string 2 selected-line))))
          (t
           (setq selected-file selected-line)))
        (when (and selected-line (file-exists-p selected-file))
          (find-file selected-file)
          (when grep-p
          (goto-char (point-min))
          (forward-line (1- (string-to-number linenum)))))
        ))))

(defun my-git-search-text-in-project ()
  "Search text of files in project root directory using git grep."
  (interactive)
  (my-file-internal (locate-dominating-file default-directory ".git") t t))

(defun my-search-text-in-project ()
  "Search text of files in project root directory."
  (interactive)
  (my-file-internal (locate-dominating-file default-directory ".git") t))

(defun my-search-text (&optional level)
  "Search text of files in current directory or LEVEL parent directory."
  (interactive "P")
  (unless level (setq level 0))
  ;; default-directory
  (let* ((parent-directory default-directory)
         (i 0))
    (while (< i level)
      ;; directory-file-name
      ;; file-name-directory
      (setq parent-directory
            (file-name-directory (directory-file-name parent-directory)))
      (setq i (+ i 1)))
    ;;2,xf
    (my-file-internal parent-directory t)))

(defun my-find-file-in-project ()
  "Find files in project root directory."
  (interactive)
  (my-file-internal (locate-dominating-file default-directory ".git")))

(defun my-find-file (&optional level)
  "Find file in current directory or LEVEL parent directory."
  (interactive "P")
  (unless level (setq level 0))
  ;; default-directory
  (let* ((parent-directory default-directory)
         (i 0))
    (while (< i level)
      ;; directory-file-name
      ;; file-name-directory
      (setq parent-directory
            (file-name-directory (directory-file-name parent-directory)))
      (setq i (+ i 1)))
    ;;2,xf
    (my-file-internal parent-directory)))
;; M-x eval-buffer
;; M-x my-search-text-in-project

> git ls-files --full-name --
Jenkinsfile
README.md
addapay/addapay-jenkinsfile
app/app-jenkinsfile
app/app-website-jenkinsfile
bigdata/bigdata-jenkinsfile

brew install vmtouch

# grep
time grep --exclude='.git' -nrs 'test' * &> /dev/null

# 使用 vmtouch 工具将目录载入到内存
vmtouch -t .

# grep
time grep --exclude='.git' -nrs 'test' * &> /dev/null

#查已经加入到内存中的文件和目录
vmtouch -v /

#从内存中去除
vmtouch -e .

(put 'company-backends 'safe-local-variable 'company-safe-backends-p)

;; M-x eval-expression (setq company-backends '(company-mytags))

(when (string-match (concat "^" prefix) item)

(defun company-mytags-candidates (prefix)
  (let* ((all-items '("hello1"
                     "hello2"
                     "test1"
                     "testtab2"
                     "testtab3"
                     "bye1"
                     "bye2"))
         (i 0)
         (pattern "^")
         rlt)
    ;; hel => ^h.*e.*l.*
    (while (< i (length prefix))
      (setq pattern (concat pattern (substring prefix i (1+ i)) ".*"))
      (setq i (1+ i)))

    (message "pattern=%s" pattern)

    (dolist (item all-items)
      (when (string-match pattern item)
        (push item rlt)))
    rlt))

(defun company-mytags (command &optional arg &rest ignored)
  "`company-mode' completion backend for GNU Global."
  (interactive (list 'interactive))
  (cl-case command
    (interactive (company-begin-backend 'company-gtags))
    (prefix (company-grab-symbol))
    (candidates (company-mytags-candidates arg))))

(setq company-backends '(company-mytags)) ;; debug code
(provide 'company-mytags)
;;; company-my-tags.el ends here

(defun company-mytags-scan-project-root ()
  (let* ((root-dir (locate-dominating-file default-directory ".git"))
         (find-cmd (format "find . -path \"*/.git\"  -prune -o -type f -iname \"*.html*\" -print"))
         (output (shell-command-to-string find-cmd))
         (files (split-string output "[\n\r]+"))
         rlt)
    (message "root-dir=%s" root-dir)
    (message "files=%s" lines)
    (setq rlt '("hello1"
                      "hello2"
                      "test1"
                      "testtab2"
                      "testtab3"
                      "bye1"
                      "bye2"))
    rlt))

(defun company-mytags-scan-project-root ()
  (let* ((root-dir (locate-dominating-file default-directory ".git"))
         (find-cmd (format "find . -path \"*/.git\"  -prune -o -type f -iname \"*.html*\" -print"))
         (output (shell-command-to-string find-cmd))
         (files (split-string output "[\n\r]+"))
         (all-content "")
         rlt)
    (message "root-dir=%s" root-dir)
    (message "files=%s" files)
    (dolist (file files)
      (when (and (not (string= file ""))
                 (file-exists-p file))
        (message "file=%s" file)
        (setq all-content (concat all-content
                                  (with-temp-buffer
                                    (insert-file-contents file)
                                    (buffer-string)
                                    )))))
    (message "all-content=%s  len=%s"
             (substring all-content 0 100)
             (length all-content))
    ;; scan root-dir
    (setq rlt '("hello1"
                "hello2"
                "test1"
                "testtab2"
                "testtab3"
                "bye1"
                "bye2"))
    rlt))

(defun company-mytags-scan-project-root ()
  (let* ((root-dir (locate-dominating-file default-directory ".git"))
         (find-cmd (format "find . -path \"*/.git\"  -prune -o -type f -iname \"*.html*\" -print"))
         (output (shell-command-to-string find-cmd))
         (files (split-string output "[\n\r]+"))
         (all-content "")
         rlt)
    (dolist (file files)
      (when (and (not (string= file ""))
                 (file-exists-p file))
        (setq all-content (concat all-content (with-temp-buffer
                                                (insert-file-contents file)
                                                (buffer-string))))))
    ;; scan root-dir
    (setq rlt (delq nil (delete-dups (sort (split-string all-content "[^a-zA-Z-_]") 'string<))))
    rlt))

(defun company-mytags-candidates (prefix)
  (let* ((all-items (company-mytags-scan-project-root))
         (i 0)
         (pattern "^")
         rlt)
    (while (< i (length prefix))
      (setq pattern (concat pattern (substring prefix i (1+ i)) ".*"))
      (setq i (1+ i)))

    (dolist (item all-items)
      (when (string-match pattern item)
        (push item rlt)))
    rlt))

(defun company-mytags (command &optional arg &rest ignored)
  "`company-mode' completion backend for GNU Global."
  (interactive (list 'interactive))
  (cl-case command
    (interactive (company-begin-backend 'company-gtags))
    (prefix (company-grab-symbol))
    (candidates (company-mytags-candidates arg))))

(setq company-backends '(company-mytags)) ;; debug code
(provide 'company-mytags)
;;; company-my-tags.el ends here
;; M-x eval-buffer

# macos
brew install ctags
alias ctags="`brew --prefix`/bin/ctags"
alias ctags >> ~/.bashrc

ctags --version
man ctags

-e 生成 emacs 兼容的格式
-R 递归搜索子目录
--exclude 排除文件

# 生成 TAGS 文件
ctags -e -R

cat TAGS
^L # 换页
company-my-tags.el,238 #文件名，文件大小
# 列出扫描出来的关键字 ^？符号 ^? 行号
(defun company-mytags-scan-project-root ()^?company-mytags-scan-project-root^A1,0
(defun company-mytags-candidates (prefix)^?company-mytags-candidates^A18,798
(defun company-mytags (command &optional arg &rest ignored)^?company-mytags^A32,1182


# 演示排除用法
mkdir subdir1
touch subdir1/hello.el
cat subdir1/hello.el
(defun helle ()
  (message "hello world"))
(defun bye ()
  (message "bye world"))

ctags -e -R
> cat TAGS
^L
company-my-tags.el,238
(defun company-mytags-scan-project-root ()^?company-mytags-scan-project-root^A1,0
(defun company-mytags-candidates (prefix)^?company-mytags-candidates^A18,798
(defun company-mytags (command &optional arg &rest ignored)^?company-mytags^A32,1182
^L
subdir1/hello.el,49
(defun helle ()^?helle^A1,0
(defun bye ()^?bye^A3,43


ctags -e -R --exclude="subdir1/*"
> cat TAGS
^L
company-my-tags.el,238
(defun company-mytags-scan-project-root ()^?company-mytags-scan-project-root^A1,0
(defun company-mytags-candidates (prefix)^?company-mytags-candidates^A18,798
(defun company-mytags (command &optional arg &rest ignored)^?company-mytags^A32,1182

# 排除当前目录下目录，和任意目录下子目录文件
ctags -e -R --exclude="subdir1/*" --exclude="*/subdir1/*" 
ctags -e -R --exclude=".git/*" --exclude="*/.git/*" --exclude=".#*"   # .#* 过滤 .#xxx 防系统崩溃的隐藏文件

cd /Users/7tq6lr/projs/company-my-tags &&  ctags -e -R --exclude=".git/*" --exclude="*/.git/*" --exclude=".#*"   # .#* 过滤 .#xxx 防系统崩溃的隐藏文件

(defun company-mytags-scan-project-root ()
  (let* ((root-dir (locate-dominating-file default-directory "TAGS"))
         (tags-file (concat root-dir "TAGS"))
         ;; ctags -e -R --exclude=".git/*" --exclude="*/.git/*"
         all-content
         (regex "^[^\177\001]+\177\\([^\177\001]+\\)\001[0-9]+,[0-9]+$")
         (start 0)
         tag-name
         rlt)
    ;; (message "tags-files=%s" tags-file)
    (when (and (file-exists-p tags-file)
               (setq all-content (with-temp-buffer
                                   (insert-file-contents tags-file)
                                   (buffer-string))))
      (while (string-match regex all-content start)
        (setq tag-name (match-string 1 all-content))
        ;; (message "----rlt=%s" rlt)
        (push tag-name rlt)
        (setq start (+ start (length (match-string 0 all-content))))
        )
      )
    ;; (message "rlt=%s" rlt)
    (setq rlt (delq nil (delete-dups (sort rlt 'string<))))
    rlt))

(defvar company-mytags-cache nil
  "Cache of tags fiel")

(defun company-mytags-scan-project-root ()
  (let* ((root-dir (locate-dominating-file default-directory "TAGS"))
         (tags-file (concat root-dir "TAGS"))
         ;; ctags -e -R --exclude=".git/*" --exclude="*/.git/*"
         all-content
         (regex "^[^\177\001]+\177\\([^\177\001]+\\)\001[0-9]+,[0-9]+$")
         (start 0)
         tag-name
         rlt)
    (when (and (file-exists-p tags-file)
               (setq all-content (with-temp-buffer
                                   (insert-file-contents tags-file)
                                   (buffer-string))))
      (while (string-match regex all-content start)
        (setq tag-name (match-string 1 all-content))
        (push tag-name rlt)
        (setq start (+ start (length (match-string 0 all-content))))))
    (setq rlt (delq nil (delete-dups (sort rlt 'string<))))
    rlt))

(defun company-mytags-candidates (prefix)
  (let* ((i 0)
         (pattern "^")
         rlt)
    ;; file cache
    (unless company-mytags-cache
      (setq company-mytags-cache (company-mytags-scan-project-root)))

    ;; matching by prefix
    (while (< i (length prefix))
      (setq pattern (concat pattern (substring prefix i (1+ i)) ".*"))
      (setq i (1+ i)))

    ;; finalize candidates
    (dolist (item company-mytags-cache)
      (when (string-match pattern item)
        (push item rlt)))
    rlt))

(defun company-mytags (command &optional arg &rest ignored)
  "`company-mode' completion backend for GNU Global."
  (interactive (list 'interactive))
  (cl-case command
    (interactive (company-begin-backend 'company-gtags))
    (prefix (company-grab-symbol))
    (candidates (company-mytags-candidates arg))))

(setq company-backends '(company-mytags)) ;; debug code
(provide 'company-mytags)
;;; company-my-tags.el ends here

(defvar company-mytags-cache nil  "Cache of tags fiel")

(defun company-mytags-update-p (tags-file)
  (let* (rlt old-modification-time file-modification-time)
    (cond
     ((not company-mytags-cache)
      (setq rlt t))
     (t
      (setq old-modification-time (plist-get company-mytags-cache
                                             'modification-time))
      (setq file-modification-time
            (float-time (nth 5 (file-attributes tags-file))))
      (message "old=%s file=%s" old-modification-time file-modification-time)
      (message "t=%s"  (- file-modification-time old-modification-time))
      (when (> (- file-modification-time old-modification-time) 4)
        (setq rlt t))))
    rlt))

(defun company-mytags-scan-project-root ()
  (let* ((root-dir (locate-dominating-file default-directory "TAGS"))
         (tags-file (concat root-dir "TAGS"))
         ;; ctags -e -R --exclude=".git/*" --exclude="*/.git/*"
         all-content
         (regex "^[^\177\001]+\177\\([^\177\001]+\\)\001[0-9]+,[0-9]+$")
         (start 0)
         tag-name
         rlt)
    (when (company-mytags-update-p tags-file)
      ;; attach file modification time
      (setq company-mytags-cache
            (plist-put company-mytags-cache
                       'modification-time
                       (float-time (nth 5 (file-attributes tags-file)))))
      (message "company-mytags-cache=%s" company-mytags-cache)
      (when (and (file-exists-p tags-file)
                 (setq all-content (with-temp-buffer
                                     (insert-file-contents tags-file)
                                     (buffer-string))))
        ;; extract tag names
        (while (string-match regex all-content start)
          (setq tag-name (match-string 1 all-content))
          (push tag-name rlt)
          (setq start (+ start (length (match-string 0 all-content))))))

      ;; update candidates
      (setq company-mytags-cache
            (plist-put company-mytags-cache
                       'candidates
                       (delq nil (delete-dups (sort rlt 'string<)))))

      (message "company-mytags-cache=%s" company-mytags-cache)
      )))

(defun company-mytags-candidates (prefix)
  (let* ((i 0)
         (pattern "^")
         rlt)
    ;; file cache
    (company-mytags-scan-project-root)

    ;; matching by prefix
    (while (< i (length prefix))
      (setq pattern (concat pattern (substring prefix i (1+ i)) ".*"))
      (setq i (1+ i)))

    ;; finalize candidates
    (dolist (item (plist-get company-mytags-cache 'candidates))
      (when (string-match pattern item)
        (push item rlt)))
    rlt))

(defun company-mytags (command &optional arg &rest ignored)
  "`company-mode' completion backend for GNU Global."
  (interactive (list 'interactive))
  (cl-case command
    (interactive (company-begin-backend 'company-gtags))
    (prefix (company-grab-symbol))
    (candidates (company-mytags-candidates arg))))

(setq company-backends '(company-mytags)) ;; debug code
(provide 'company-mytags)
;;; company-my-tags.el ends here

;; M-x eval-buffer
;; 清空缓存 （setq company-mytags-cache nil）
;; 本目录下打开个新文件，M-x eval-expression (setq company-backends '(company-mytags))

mkdir ~/projs/my-codenav

> cat bye.js
function bye1() {
}

function bye2() {
}

> cat hello.js
function hello1() {
}

function hello2() {
}%

ctags -e -R *.js

emacs -nw my-codenav.el

(require 'ivy)
(require 'xref)
(defun my-codenav ()
  "My code navigation tool."
  (interactive)
  (let* ((root-dir (locate-dominating-file default-directory "TAGS"))
         (tags-file (concat root-dir "TAGS"))
         (symbol (thing-at-point 'symbol))
         candidates ;; 等价于nil '()
         all-content
         cur-line
         selected
         (regex "^\\([^\177\001]+\\)\177\\([^\177\001]+\\)\001\\([0-9]+\\),[0-9]+$")
         (default-directory root-dir))
    (setq all-content (with-temp-buffer
                        (insert-file-contents tags-file)
                        (buffer-string)))
    (when (and symbol (not (string= symbol "")))
      (with-temp-buffer
        (insert all-content)
        (goto-char (point-min))
        ;; push all matches into candidates
        (while (search-forward-regexp (concat "\177" symbol "\001") (point-max) t)
          (setq cur-line (buffer-substring (line-beginning-position) (line-end-position)))
          (when (string-match regex cur-line)
            (let* ((code-line (match-string 1 cur-line))
                   (line-num (match-string 3 cur-line))
                   (file (etags-file-of-tag t)))
              (push (format "%s:%s:%s" file line-num code-line) candidates)))
          (forward-line)))
      (when (and candidates (setq selected (ivy-read "Naviget to: " candidates)))
        (when (string-match "^\\([^:]+\\):\\([0-9]+\\):.*" selected)
          (let* ((file (match-string 1 selected))
                 (line-num (match-string 2 selected)))
            (message "file=%s line=%s" file line-num)
            (when (and file (file-exists-p file))
              (xref-push-marker-stack (point-marker))
              (find-file file)
              (goto-char (point-min))
              (forward-line (1- (string-to-number line-num)))
              (xref-pulse-momentarily))))))))

mkdir ~/projs/my-syntax-check

-l --load 载入文件
-batch 不交互式显示，直接输出到控制台
-Q 快速输出

# hello.txt
hello world.
hello world.
hello world.
hello world.
hello world.
bye world.
bye world.

> cat my-syntax-checker.el
(message "hello world")
> e -Q -batch -l my-syntax-checker.el
hello world

> cat my-syntax-checker.el
(message "hello world")
(message "command-line-args-left=%s" command-line-args-left)


> emacs -Q -batch -l my-syntax-checker.el hello.txt
hello world
command-line-args-left=(hello.txt)
my-syntax-checker:hello.txt:3:space at the end of line
my-syntax-checker:hello.txt:6:space at the end of line

(let* ((file (nth 0 command-line-args-left))
       (i 0)
       lines
       all-content)
(when (file-exists-p file)
  (setq all-content (with-temp-buffer
                      (insert-file-contents file)
                      (buffer-string)))
  (setq lines (split-string all-content "\n"))
  (while (< i (length lines))
    (when (string-match " +$" (nth i lines))
      (message "my-syntax-checker:%s:%s:space at the end of line"
               file
               (1+ i)))
    (setq i (1+ i)))))


> emacs -Q -batch -l my-syntax-checker.el hello.txt
my-syntax-checker:hello.txt:3:space at the end of line
my-syntax-checker:hello.txt:6:space at the end of line

  (list "emacs"
        (list "-Q"
              "-batch"
              "-l"
              "/Users/7tq6lr/projs/my-syntax-check/my-syntax-checker.el"
              buffer-file-name)))
(push (list "\\.txt$" 'my-flymake-txt-init) flymake-allowed-file-name-masks)
;;my-syntax-checker:hello.txt:3:space at the end of line
(push (list "^my-syntax-checker:\\([^:]+\\):\\([0-9]+\\):\\(.*\\)$" 1 2 nil 3)
      flymake-err-line-patterns)

sudo apt install aspell aspell-en
#mac
brew install aspell

/Users/7tq6lr/projs/my-syntax-check [7tq6lr@7tq6lrdeMacBook-Air] [6:40]
> echo "hello world" | aspell pipe --lang en
@(#) International Ispell Version 3.1.20 (but really Aspell 0.60.8)
*
*


/Users/7tq6lr/projs/my-syntax-check [7tq6lr@7tq6lrdeMacBook-Air] [6:41]
> echo "helle world" | aspell pipe --lang en
@(#) International Ispell Version 3.1.20 (but really Aspell 0.60.8)
& helle 29 0: Heller, hell, hello, heel, he'll, helve, belle, Halley, Hallie, Holley, Hollie, healer, holler, huller, Hale, Hall, Hill, Hull, hale, hall, heal, hill, hole, hull, Holly, Hoyle, hilly, holly, hell's
*

# 支持驼峰拼写检查，0.60.8版本 完成支持
> echo "helloWorld" | aspell pipe --lang en --run-together
@(#) International Ispell Version 3.1.20 (but really Aspell 0.60.8)
-

mkdir -p  ~/projs/my-spellcheck
cd ~/projs/my-spellcheck
touch my-spellcheck.el
cat my-spellcheck.el
(defun my-spell-check-start ()
  (interactive)
  (message "hello world"))



cat hello.js
function hello() {
  console.log('hello,world');
  console.log('hell,world');
}

(require 'flyspell)
;; use `flyspell-buffer'
(setq ispell-program-name "aspell")
(setq ispell-extra-args '("--lang=en" "--run-together"))
(defun my-spell-check-start ()
  (interactive)
  (flyspell-buffer))

(require 'flyspell)
;; use `flyspell-buffer'
(setq ispell-program-name "aspell")
(setq ispell-extra-args '("--lang=en" "--run-together"))
(defun my-predicate ()
  (let* ((pos (1- (point)))
         (font-face-at-point (get-text-property pos 'face)))
    (memq font-face-at-point '(font-lock-string-face
                               font-lock-comment-face
                               font-lock-function-name-face
                               font-lock-variable-name-face))
    ))

(defun my-spell-check-start ()
  (interactive)
  (setq flyspell-generic-check-word-predicate 'my-predicate)
  (flyspell-buffer))

;; (add-hook 'after-save-hook 'my-spell-check-start nil t)
(defun my-mode-hook-setup ()
  (add-hook 'after-save-hook 'my-spell-check-start nil t))
(add-hook 'js2-mode-hook 'my--mode-hook-setup)

(require 'flyspell)
;; use `flyspell-buffer'
(setq ispell-program-name "aspell")
(setq ispell-extra-args '("--lang=en" "--run-together"))
(defun my-predicate ()
  (let* ((pos (1- (point)))
         (font-face-at-point (get-text-property pos 'face)))
    ;;; ...skip some logic .....
    (memq font-face-at-point '(font-lock-string-face
                               font-lock-comment-face
                               font-lock-variable-name-face
                               font-lock-function-name-face))))
(defun my-spell-check-start ()
  (interactive)
  (let* (begin end (height (window-body-height)))
    (message "my-spell-check-start called")
    (setq flyspell-generic-check-word-predicate 'my-predicate)
    ;; (point)
    (save-excursion
      (forward-line (- height))
      (setq begin (line-beginning-position)))
    (save-excursion
      (forward-line height)
      (setq end (line-end-position)))
    (flyspell-region begin end)))

;; (add-hook 'after-save-hook 'my-spell-check-start nil t)
(defun my-mode-hook-setup ()
  (add-hook 'after-save-hook 'my-spell-check-start nil t))
(add-hook 'js2-mode-hook 'my-mode-hook-setup)

[number]<operator>[text object or motion]
<数字> <操作符> <文本对象或移动命令>

mkdir -p ~/projs/my-evil-textobj
cd ~/projs/my-evil-textobj
touch my-evil-textobj.el

cat hello.js
function bye() {
}
function hello() {
  let v1 = bye();
}

(require 'evil)

(evil-define-text-object evil-a-word (count &optional beg end type)
  "Select a word."
  (evil-select-a-restricted-object 'evil-word beg end type count))

(evil-define-text-object evil-inner-word (count &optional beg end type)
  "Select inner word."
  (evil-select-inner-restricted-object 'evil-word beg end type count))
(define-key evil-outer-text-objects-map "w" 'evil-a-word)
(define-key evil-inner-text-objects-map "w" 'evil-inner-word)
;;press `viw'evil-inner-word  `vaw' evil-a-word
;; "word" vi" va"
;; (word) vi( va(
;; i 不包括边界，a 包括边界

(require 'evil)

(evil-define-text-object my-evil-a-textobj (count &optional beg end type)
  "Select a word."
  (let* ((rlt (evil-select-a-restricted-object 'evil-word beg end type count)))
    (message "rlt=%s" rlt)
    (setq rlt '(28 34))
    rlt))

(evil-define-text-object my-evil-inner-textobj (count &optional beg end type)
  "Select inner word."
  (evil-select-inner-restricted-object 'evil-word beg end type count))
(define-key evil-outer-text-objects-map "t" 'my-evil-a-textobj)
(define-key evil-inner-text-objects-map "t" 'my-evil-inner-textobj)
;;press `viw'evil-inner-word  `vaw' evil-a-word

(message "hello world")
(defun after-save-hook-setup ()
  (message "buffer-file-name=%s" buffer-file-name)
  (message "after-save-hook-setup called"))
;;aafafalj
(add-hook 'after-save-hook 'after-save-hook-setup)

(advice-remove 'my-double #'my-increase)