feat: add develop environment for ruby

This commit is contained in:
Ryan Yin
2024-03-14 00:30:32 +08:00
parent bcc8d2302c
commit 4d3a3750c1
67 changed files with 54 additions and 31 deletions
+62
View File
@@ -0,0 +1,62 @@
# Editors Glossary
### LSP - Language Server Protocol
> https://en.wikipedia.org/wiki/Language_Server_Protocol
> https://langserver.org/
The Language Server Protocol (LSP) is an open, JSON-RPC-based protocol for use between source code editors or integrated development environments (IDEs) and servers that provide programming language-specific features like:
- motions such as go-to-definition, find-references, hover.
- **code completion**
- **marking of warnings and errors**
- **refactoring routines**
- syntax highlighting (use Tree-sitter instead)
- code formatting (use a dedicated formatter instead)
The goal of the protocol is to allow programming language support to be implemented and distributed independently of any given editor or IDE.
LSP was originally developed for Microsoft Visual Studio Code and is now an open standard.
In the early 2020s LSP quickly became a "norm" for language intelligence tools providers.
### Tree-sitter
> https://tree-sitter.github.io/tree-sitter/
> https://www.reddit.com/r/neovim/comments/1109wgr/treesitter_vs_lsp_differences_ans_overlap/
Tree-sitter is a parser generator tool and an **incremental parsing** library. It can build a concrete syntax tree for a source file and efficiently update the syntax tree as the source file is edited.
It is used by many editors and IDEs to provide:
- **syntax highlighting**
- **indentation**
- **creating foldable code regions**
- **Incremental selection**
- **simple refactoring in a single file**
- such as join/split lines, structural editing, cursor motion, etc.
**Treesitter process each file independently**, and it is not aware of the semantics of your code.
For example, it does not know does a function/variable really exist, or what is the type/return-type of a variable. This is where LSP comes in.
The LSP server parses the code much more deeply and it **not only parses a single file but your whole project**.
So, the LSP server will know whether a function/variable does exist with the same type/return-type. If it does not, it will mark it as an error.
**LSP does understand the code semantically, while Treesitter only cares about correct syntax**.
#### LSP vs Tree-sitter
- Tree-sitter: lightweight, fast, but limited knowledge of your code. mainly used for **syntax highlighting, indentation, and folding/refactoring in a single file**.
- LSP: heavy and slow on large projects, but it has a deep understanding of your code. mainly used for **code completion, refactoring in the projects, errors/warnings, and other semantic-aware features**.
### Formatter vs Linter
Linting is distinct from Formatting because:
1. **formatting** only restructures how code appears.
1. `prettier` is a popular formatter.
1. **linting** analyzes how the code runs and detects errors, it may also suggest improvements such as replace `var` with `let` or `const`.
Formatters and Linters process each file independently, they do not need to know about other files in the project.
* [ ]
+206
View File
@@ -0,0 +1,206 @@
# Editors
My editors:
1. Neovim
2. Emacs
3. Helix
And `Zellij` for a smooth and stable terminal experience.
## Tips
1. Many useful keys are already provided by vim, check vim/neovim's docs before you install a new plugin / reinvent the wheel.
1. After using Emacs/Neovim more skillfully, I strongly recommend that you read the official documentation of Neovim/vim:
1. <https://vimhelp.org/>: The official vim documentation.
1. <https://neovim.io/doc/user/>: Neovim's official user documentation.
1. Use Zellij for terminal related operations, and use Neovim/Helix for editing.
1. As for Emacs, Use its GUI version & terminal emulator `vterm` for terminal related operations.
1. Two powerful file search & jump tools:
1. Tree-view plugins are beginner-friendly and intuitive, but they're not very efficient.
1. **Search by the file path**: Useful when you're familiar with the project structure, especially on a large project.
1. **Search by the content**: Useful when you're familiar with the code.
## Tutorial
Type `:tutor`(`:Tutor` in Neovim) to learn the basics usage of vim/neovim.
## VIM's Cheetsheet
> Here only record my commonly used keys, to see **a more comprehensive cheetsheet**: <https://vimhelp.org/quickref.txt.html>
Both Emacs-Evil & Neovim are compatible with vim, sothe key-bindings described here are common in both Emacs-Evil, Neovim & vim.
### Terminal Related
I mainly use Zellij for terminal related operations, here is its terminal shortcuts I use frequently now:
| Action | Zellij's Shortcut |
| ------------------------- | ----------------- |
| Floating Terminal | `Ctrl + p + w` |
| Horizontal Split Terminal | `Ctrl + p + d` |
| Vertical Split Terminal | `Ctrl + p + n` |
| Execute a command | `!xxx` |
### File Management
> <https://neovim.io/doc/user/usr_22.html>
> <https://vimhelp.org/editing.txt.html>
| Action | |
| ----------------------------------- | ------------------------------------------------ |
| Save selected text to a file | `:w filename` (Will show `:'<,'>w filename`) |
| Save and close the current buffer | `:wq` |
| Save all buffers | `:wa` |
| Save and close all buffers | `:wqa` |
| Edit a file | `:e filename`(or `:e <TAB>` to show a file list) |
| Browse the file list | `:Ex` or `:e .` |
| Discard changes and reread the file | `:e!` |
### Motion
> https://vimhelp.org/motion.txt.html
| Action | Command |
| --------------------------------------------------- | -------------------------------------------------- |
| Move to the start/end of the buffer | `gg`/`G` |
| Move the line number 5 | `5gg` / `5G` |
| Move left/down/up/right | h/j/k/l or `5h`/`5j`/`5k`/`5l` or `Ctr-n`/`Ctrl-p` |
| Move to the matchpairs, default to `()`, `{}`, `[]` | `%` |
| Move to the start/end of the line | `0` / `$` |
| Move a sentence forward/backward | `(` / `)` |
| Move a paragraph forward/backward | `{` / `}` |
| Move a section forward/backward | `[[` / `]]` |
| Jump to various positions | `'` + some other keys(neovim has prompt) |
Text Objects:
- **sentence**: text ending at a '.', '!' or '?' followed by either the end of a line, or by a space or tab.
- **paragraph**: text ending at a blank line.
- **section**: text starting with a section header and ending at the start of the next section header (or at the end of the file). - The "`]]`" and "`[[`" commands stop at the '`{`' in the first column. This is
useful to find the start of a function in a C/Go/Java/... program.
### Text Manipulation
Basics:
| Action | |
| --------------------------------------- | -------------------------- |
| Delete the current character | `x` |
| Paste the copied text | `p` |
| Delete the selection | `d` |
| Undo the last word | `CTRL-w`(in insert mode) |
| Undo the last line | `CTRL-u`(in insert mode) |
| Undo the last change | `u` |
| Redo the last change | `Ctrl + r` |
| Inserts the text of the previous insert | `Ctrl + a` |
| Repeat the last command | `.` |
| Toggle text's case | `~` |
| Convert to uppercase | `U` (visual mode) |
| Convert to lowercase | `u` (visual mode) |
| Align the selected conent | `:center`/`:left`/`:right` |
Misc:
| Action | Shortcut |
| ----------------------------- | ---------------------------------------- |
| Toggle visual mode | `v` (lower case v) |
| Select the current line | `V` (upper case v) |
| Toggle visual block mode | `<Ctrl> + v` (select a block vertically) |
| Fold the current code block | `zc` |
| Unfold the current code block | `zo` |
| Jump to Definition | `gd` |
| Jump to References | `gD` |
| (Un)Comment the current line | `gcc` |
| Action | |
| ------------------------------------------------------------------------- | -------------- |
| Sort tye selected lines | `:sort` |
| Join Selection of Lines With Space | `:join` or `J` |
| Join without spaces | `:join!` |
| Enter Insert mode at the start/end of the line | `I` / `A` |
| Delete from the cursor to the end of the line | `D` |
| Delete from the cursor to the end of the line, and then enter insert mode | `C` |
Advance Techs:
- Add at the end of multiple lines: `:normal A<text>`
- Execublock: `:A<text>`
- visual block mode(ctrl + v)
- Append text at the end of each line in the selected block
- If position exceeds line end, neovim adds spaces automatically
- Delete the last char of multivle lines: `:normal $x`
- Execute `$x` on each line
- visual mode(v)
- `$` moves cursor to the end of line
- `x` deletes the character under the cursor
- Delete the last word of multiple lines: `:normal $bD`
- Execute `$bD` on each line
- visual mode(v)
- `$` moves cursor to the end of line
- `b` moves cursor to the beginning of the last word
### Search
| Action | Command |
| ----------------------------------------------------- | --------- |
| Search forward/backword for a pattern | `/` / `?` |
| Repeat the last search in the same/opposite direction | `n` / `N` |
### Find and Replace
| Action | Command |
| -------------------------------- | ----------------------------------- |
| Replace in selected area | `:s/old/new/g` |
| Replace in current line | Same as above |
| Replace all the lines | `:% s/old/new/g` |
| Replace all the lines with regex | `:% s@\vhttp://(\w+)@https://\1@gc` |
1. `\v` means means that in the regex pattern after it can be used without backslash escaping(similar to python's raw string).
2. `\1` means the first matched group in the pattern.
### Replace in the specific lines
| Action | Command |
| ----------------------------------------- | -------------------------------------- |
| From the 10th line to the end of the file | `:10,$ s/old/new/g` or `:10,$ s@^@#@g` |
| From the 10th line to the 20th line | `:10,20 s/old/new/g` |
| Remove the trailing spaces | `:% s/\s\+$//g` |
The postfix(flags) in the above commands:
1. `g` means replace all the matched strings in the current line/file.
2. `c` means ask for confirmation before replacing.
3. `i` means ignore case.
### Buffers, Windows and Tabs
> <https://neovim.io/doc/user/usr_08.html>
> <https://vimhelp.org/windows.txt.html>
- A buffer is the in-memory text of a file.
- A window is a viewport on a buffer.
- A tab page is a collection of windows.
| Action | Command |
| ----------------------------------- | ----------------------------------- |
| Split the window horizontally | `:sp[lit]` or `:sp filename` |
| Split the window horizontally | `:vs[plit]` or `:vs filename` |
| Switch to the next/previous window | `Ctrl-w + w` or `Ctrl-w + h/j/k/l` |
| Show all buffers | `:ls` |
| show next/previous buffer | `]b`/`[b` or `:bn[ext]` / `bp[rev]` |
| New Tab(New Workspace in DoomEmacs) | `:tabnew` |
| Next/Previews Tab | `gt`/`gT` |
### History
| Action | Command |
| ------------------------ | ------- |
| Show the command history | `q:` |
| Show the search history | `q/` |
@@ -0,0 +1,24 @@
# Structured Editing
## S-expression data(Lisp)
- paredit/[lispy](https://github.com/doomemacs/doomemacs/tree/master/modules/editor/lispy): too complex.
- [evil-cleverparens](https://github.com/emacs-evil/evil-cleverparens): simple and useful.
- [parinfer(par-in-fer)](https://shaunlebron.github.io/parinfer/): morden, simple, elegant and useful, but works not well with some other completion plugins...
- to make parinfer works, you should disable sexp & smartparens in any lisp mode.
Some plugins:
- Emacs
- [parinfer-rusT-mode](https://github.com/justinbarclay/parinfer-rust-mode)
- Neovim
- [parinfer-rust](https://github.com/eraserhd/parinfer-rust)
- <https://github.com/Olical/conjure>
- Helix
- [parinfer #4090 - Helix](https://github.com/helix-editor/helix/discussions/4090)
## Other Languages
1. treesitter
1. ...
+3
View File
@@ -0,0 +1,3 @@
{mylib, ...}: {
imports = mylib.scanPaths ./.;
}
+223
View File
@@ -0,0 +1,223 @@
# Emacs Editor
## Why emacs?
1. Explore the unknown, just for fun!
2. Org Mode
3. Lisp Coding
4. A top-level tutorial for Emacs(Chinese): <https://nyk.ma/tags/emacs/>
5. A Beginner's Guide to Emacs(Chinese): <https://github.com/emacs-tw/emacs-101-beginner-survival-guide>
## Screenshot
![](/_img/emacs-2024-01-07.webp)
## Usefull Links
- Framework: <https://github.com/doomemacs/doomemacs>
- key bindings:
- source code: <https://github.com/doomemacs/doomemacs/blob/master/modules/config/default/%2Bevil-bindings.el>
- docs: <https://github.com/doomemacs/doomemacs/blob/master/modules/editor/evil/README.org>
- module index: <https://github.com/doomemacs/doomemacs/blob/master/docs/modules.org>
- LSP Client: <https://github.com/manateelazycat/lsp-bridge>
- Emacs Wiki: <https://www.emacswiki.org/emacs/SiteMap>
- Awesome Emacs: <https://github.com/emacs-tw/awesome-emacs#lsp-client>
- Chinese(rime) support: <https://github.com/DogLooksGood/emacs-rime>
- modal editing:
- <https://github.com/emacs-evil/evil>: evil mode, enabled by default in doom-emacs.
- <https://github.com/meow-edit/meow>
## Install or Update
After deploying this nix flake, run the following command to install or update emacs:
```bash
doom sync
```
when in doubt, run `doom sync`!
## Testing
> via `Justfile` located at the root of this repo.
```bash
# testing
just emacs-test
jsut emacs-purge
just emacs-reload
# clear test data
just emacs-clean
```
## Limits
- It's too slow to start up and install(compile/build) packages.
- I have to use emacs in daemon/client mode to avoid this issue.
- It's too large in size, not suitable for servers.
- So vim/neovim is still the best choice for servers.
- Emacs's markdown-mode works not well with tables, see:
- https://github.com/jrblevin/markdown-mode/issues/380
- I use git command frequently, but doomemacs only autoupdates status of git diff / treemacs when using magit.
- I have to learn magit to avoid this issue...
- GitHub's orgmode support is not well, Markdown is better for GitHub.
- Use markdown for repo's README.md, and use orgmode for my personal notes and docs only.
## Cheetsheet
Here is the cheetsheet related to my DoomEmacs configs. Please read vim's common cheetsheet at [../README.md](../README.md) before reading the following.
### Basics
> Terminal(vterm) is useful in GUI mode, I use Zellij instead in terminal mode.
| Action | Shortcut |
| ---------------------- | ------------------------------------------------- |
| Popup Terminal(vterm) | `SPC + o + t` |
| Open Terminal | `SPC + o + T` |
| Open file tree sidebar | `SPC + o + p` |
| Frame fullscreen | `SPC + t + F` |
| Exit | `M-x C-c` |
| Execute Command | `M-x`(hold on `Alt`/`option`, and then press `x`) |
| Eval Lisp Code | `M-:`(hold on `Alt`/`option`, and then press `:`) |
### Window Navigation
| Action | Shortcut |
| ------------------------------------------ | --------------------------------------------------------------------- |
| Split a window vertically and horizontally | `SPC w v/s` |
| Move to a window in a specific direction | `Ctrl-w + h/j/k/l` |
| Move a window to a specific direction | `Ctrl-w + H/J/K/L` |
| Move to the next window | `SPC w w` |
| Close the current window | `SPC w q` |
| Rebalance all windows | `SPC w =` |
| Set window's width(columns) | `80 SPC w \|` (the Vertical line is escaped due to markdown's limits) |
| Set window's height | `30 SPC w _ ` |
### File Tree
- treemacs: <https://github.com/Alexander-Miller/treemacs/blob/master/src/elisp/treemacs-mode.el>
- treemacs-evil: <https://github.com/Alexander-Miller/treemacs/blob/master/src/extra/treemacs-evil.el>
| Action | Shortcut |
| ------------------------------------- | --------- |
| Resize Treemacs's window | `>` & `<` |
| Extra Wide Window | `W` |
| Rename | `R` |
| Delete File/Direcoty | `d` |
| New File | `cf` |
| New Directory | `cd` |
| Go to parent | `u` |
| Run shell command in for current node | `!` |
| Refresh file tree | `gr` |
| Copy project-path into pasteboard | `yp` |
| Copy absolute-path into pasteboard | `ya` |
| Copy relative-path into pasteboard | `yr` |
| Copy file to another location | `yf` |
| Move file to another location | `m` |
| quit | `q` |
And bookmarks:
- Add bookmarks in treemacs: `b`
- Show Bookmark List: `SPC s m`
### Splitting and Buffers
| Action | Shortcut |
| ----------------------- | ----------------- |
| Buffer List | `<Space> + ,` |
| Save all buffers(Tab) | `<Space> + b + S` |
| Kill the current buffer | `<Space> + b + k` |
| Kill all buffers | `<Space> + b + K` |
### Editing and Formatting
| Action | Shortcut |
| ------------------------------------------ | ------------------- |
| Format Document | `<Space> + cf` |
| Code Actions | `<Space> + ca` |
| Rename | `<Space> + cr` |
| Opening LSP symbols | `<Space> + cS` |
| Show all LSP Errors | `<Space> + c + x/X` |
| Show infinite undo history(really useful!) | `<Space> + s + u` |
| Open filepath/URL at cursor | `gf` |
| Find files by keyword in path | `<Space> + <Space>` |
| Grep string in files (vertico + ripgrep) | `<Space> + sd` |
### Image Preview(GUI mode only)
Use `-`, `+` to resize the image, `r` to rotate the image.
### Search & replace
```bash
SPC s p foo C-; E C-c C-p :%s/foo/bar/g RET Z Z
```
1. `SPC s p`: search in project
1. `foo`: the keyword to search
1. `C-; E`: exports what youre looking at into a new buffer in grep-mode
1. `C-c C-p` to run wgrep-change-to-wgrep-mode to make the search results writable.
1. `:%s/foo/bar/g RET`: replace in the current buffer(just like neovim/vim)
1. `Z Z`: to write all the changes to their respective files
### Projects
> easily switch between projects without exit emacs!
| Action | Shortcut |
| -------------------------- | ------------- |
| Switch between projects | `SPC + p + p` |
| Browse the current project | `SPC + p + .` |
| Add new project | `SPC + p + a` |
### Workspaces
> Very useful when run emacs in daemon/client modes
| Action | Shortcut |
| --------------------------- | --------------------------- |
| Switch between workspaces | `M-1/2/3/...`(Alt-1/2/3/..) |
| New Workspace | `SPC + TAB + n` |
| New Named Workspace | `SPC + TAB + N` |
| Delete Workspace | `SPC + TAB + d` |
| Display Workspaces bar blow | `SPC + TAB + TAB` |
### Magit
> https://github.com/magit/magit
Magit is a powerful tool that make git operations easy and intuitive.
| Action | Shortcut |
| ------------------------ | ------------------------ |
| Open Magit | `C-x g` or `SPC + g + g` |
| Switch branch | `SPC + g + b` |
| Show buffer's commit log | `SPC + g + L` |
Shortcuts in magit's pane:
> When run `git commit` / `git add` / `git push` /... via magit, multiple Arguments can be set.
> Set arguments won't trigger a git command immediately. Magit will try to run a git command only after an Action key is pressed.
| Action | Shortcut |
| -------------------------------------------------- | --------------------------------------------- |
| Quit the current Magit pane | `q` |
| Show log | `l` |
| Show current branch's log | `l + l` |
| Show current reflog | `l + r` |
| Commit | `c` |
| Stage | `s` |
| Unstage | `u` |
| Push | `p` |
| Pull | `f` |
| Rebase | `r` |
| Rebase Interactively | `r + i`, select on a commit, then `C-c + C-c` |
| Stash | `z` |
| Merge | `m` |
| Fold/Unfold | `TAB` |
| Show details of the current unit(commit/stage/...) | `<ENTER>` |
KeyBinding full list: <https://github.com/emacs-evil/evil-collection/tree/master/modes/magit#key-bindings>
+132
View File
@@ -0,0 +1,132 @@
# ==============================================
# Based on doomemacs's auther's config:
# https://github.com/hlissner/dotfiles/blob/master/modules/editors/emacs.nix
#
# Emacs Tutorials:
# 1. Official: <https://www.gnu.org/software/emacs/tour/index.html>
# 2. Doom Emacs: <https://github.com/doomemacs/doomemacs/blob/master/docs/index.org>
#
{
config,
lib,
pkgs,
doomemacs,
...
}:
with lib; let
cfg = config.modules.editors.emacs;
envExtra = ''
export PATH="${config.xdg.configHome}/emacs/bin:$PATH"
'';
shellAliases = {
e = "emacsclient --create-frame"; # gui
et = "emacsclient --create-frame --tty"; # termimal
};
librime-dir = "${config.xdg.dataHome}/emacs/librime";
parinfer-rust-lib-dir = "${config.xdg.dataHome}/emacs/parinfer-rust";
myEmacsPackagesFor = emacs: ((pkgs.emacsPackagesFor emacs).emacsWithPackages (epkgs: [
epkgs.vterm
]));
in {
options.modules.editors.emacs = {
enable = mkEnableOption "Emacs Editor";
};
config = mkIf cfg.enable (mkMerge [
{
home.packages = with pkgs; [
## Doom dependencies
git
(ripgrep.override {withPCRE2 = true;})
gnutls # for TLS connectivity
## Optional dependencies
fd # faster projectile indexing
imagemagick # for image-dired
fd # faster projectile indexing
zstd # for undo-fu-session/undo-tree compression
# go-mode
# gocode # project archived, use gopls instead
## Module dependencies
# :checkers spell
(aspellWithDicts (ds: with ds; [en en-computers en-science]))
# :tools editorconfig
editorconfig-core-c # per-project style config
# :tools lookup & :lang org +roam
sqlite
# :lang latex & :lang org (latex previews)
# texlive.combined.scheme-medium
];
programs.bash.bashrcExtra = envExtra;
programs.zsh.envExtra = envExtra;
home.shellAliases = shellAliases;
programs.nushell.shellAliases = shellAliases;
xdg.configFile."doom" = {
source = ./doom;
force = true;
};
home.activation.installDoomEmacs = lib.hm.dag.entryAfter ["writeBoundary"] ''
${pkgs.rsync}/bin/rsync -avz --chmod=D2755,F744 ${doomemacs}/ ${config.xdg.configHome}/emacs/
# librime for emacs-rime
mkdir -p ${librime-dir}
${pkgs.rsync}/bin/rsync -avz --chmod=D2755,F744 ${pkgs.librime}/ ${librime-dir}/
# libparinfer_rust for emacs' parinfer-rust-mode
mkdir -p ${parinfer-rust-lib-dir}
${pkgs.rsync}/bin/rsync -avz --chmod=D2755,F744 ${pkgs.vimPlugins.parinfer-rust}/lib/libparinfer_rust.* ${parinfer-rust-lib-dir}/parinfer-rust.so
'';
}
(mkIf pkgs.stdenv.isLinux (
let
# Do not use emacs-nox here, which makes the mouse wheel work abnormally in terminal mode.
# pgtk (pure gtk) build add native support for wayland.
# https://www.gnu.org/savannah-checkouts/gnu/emacs/emacs.html#Releases
emacsPkg = myEmacsPackagesFor pkgs.emacs29-pgtk;
in {
home.packages = [emacsPkg];
services.emacs = {
enable = true;
package = emacsPkg;
client = {
enable = true;
arguments = [" --create-frame"];
};
startWithUserSession = true;
};
}
))
(mkIf pkgs.stdenv.isDarwin (
let
# macport adds some native features based on GNU Emacs 29
# https://bitbucket.org/mituharu/emacs-mac/src/master/README-mac
emacsPkg = myEmacsPackagesFor pkgs.emacs29;
in {
home.packages = [emacsPkg];
launchd.enable = true;
launchd.agents.emacs = {
enable = true;
config = {
ProgramArguments = [
"${pkgs.bash}/bin/bash"
"-l"
"-c"
"${emacsPkg}/bin/emacs --fg-daemon"
];
StandardErrorPath = "${config.home.homeDirectory}/Library/Logs/emacs-daemon.stderr.log";
StandardOutPath = "${config.home.homeDirectory}/Library/Logs/emacs-daemon.stdout.log";
RunAtLoad = true;
KeepAlive = true;
};
};
}
))
]);
}
+175
View File
@@ -0,0 +1,175 @@
;;; $DOOMDIR/config.el -*- lexical-binding: t; -*-
;; Place your private configuration here! Remember, you do not need to run 'doom
;; sync' after modifying this file!
;; Some functionality uses this to identify you, e.g. GPG configuration, email
;; clients, file templates and snippets. It is optional.
;; (setq user-full-name "John Doe"
;; user-mail-address "john@doe.com")
;; Doom exposes five (optional) variables for controlling fonts in Doom:
;;
;; - `doom-font' -- the primary font to use
;; - `doom-variable-pitch-font' -- a non-monospace font (where applicable)
;; - `doom-big-font' -- used for `doom-big-font-mode'; use this for
;; presentations or streaming.
;; - `doom-symbol-font' -- for symbols
;; - `doom-serif-font' -- for the `fixed-pitch-serif' face
;;
;; See 'C-h v doom-font' for documentation and more examples of what they
;; accept. For example:
;;
(setq doom-font (font-spec :family "JetBrainsMono Nerd Font" :size 18)
doom-variable-pitch-font (font-spec :family "DejaVu Sans")
doom-symbol-font (font-spec :family "Symbols Nerd Font Mono")
doom-big-font (font-spec :family "JetBrainsMono Nerd Font" :size 28))
;; Users should inject their own font logic in `after-setting-font-hook'
;; Add font for CJK charset
(defun init-cjk-fonts()
(dolist (charset '(kana han cjk-misc bopomofo))
(set-fontset-font (frame-parameter nil 'font)
charset (font-spec :family "Source Han Sans SC"))))
(add-hook 'after-setting-font-hook 'init-cjk-fonts)
;; If you or Emacs can't find your font, use 'M-x describe-font' to look them
;; up, `M-x eval-region' to execute elisp code, and 'M-x doom/reload-font' to
;; refresh your font settings. If Emacs still can't find your font, it likely
;; wasn't installed correctly. Font issues are rarely Doom issues!
;; There are two ways to load a theme. Both assume the theme is installed and
;; available. You can either set `doom-theme' or manually load a theme with the
;; `load-theme' function. This is the default:
;; other doom's official themes:
;; https://github.com/doomemacs/themes
(setq doom-theme 'doom-dracula) ;; doom-one doom-dracula doom-nord
(if (eq system-type 'darwin)
;; Transparent Backgroud - for macOS
;;(set-frame-parameter (selected-frame) 'alpha '(<active> . <inactive>))
;;(set-frame-parameter (selected-frame) 'alpha <both>)
(progn
(set-frame-parameter (selected-frame) 'alpha '(85 . 70))
(add-to-list 'default-frame-alist '(alpha . (85 . 70))))
;; Transparent Background - for Linux Xorg/Wayland
(set-frame-parameter nil 'alpha-background 93) ; For current frame
(add-to-list 'default-frame-alist '(alpha-background . 93))); For all new frames henceforth
;; This determines the style of line numbers in effect. If set to `nil', line
;; numbers are disabled. For relative line numbers, set this to `relative'.
(setq display-line-numbers-type t)
(setq warning-minimum-level :error)
;; If you use `org' and don't want your org files in the default location below,
;; change `org-directory'. It must be set before org loads!
(setq org-directory "~/org/")
;; Whenever you reconfigure a package, make sure to wrap your config in an
;; `after!' block, otherwise Doom's defaults may override your settings. E.g.
;;
;; (after! PACKAGE
;; (setq x y))
;;
;; The exceptions to this rule:
;;
;; - Setting file/directory variables (like `org-directory')
;; - Setting variables which explicitly tell you to set them before their
;; package is loaded (see 'C-h v VARIABLE' to look up their documentation).
;; - Setting doom variables (which start with 'doom-' or '+').
;;
;; Here are some additional functions/macros that will help you configure Doom.
;;
;; - `load!' for loading external *.el files relative to this one
;; - `use-package!' for configuring packages
;; - `after!' for running code after a package has loaded
;; - `add-load-path!' for adding directories to the `load-path', relative to
;; this file. Emacs searches the `load-path' when you load packages with
;; `require' or `use-package'.
;; - `map!' for binding new keys
;;
;; To get information about any of these functions/macros, move the cursor over
;; the highlighted symbol at press 'K' (non-evil users must press 'C-c c k').
;; This will open documentation for it, including demos of how they are used.
;; Alternatively, use `C-h o' to look up a symbol (functions, variables, faces,
;; etc).
;;
;; You can also try 'gd' (or 'C-c c d') to jump to their definition and see how
;; they are implemented.
;; use alejandra to format nix files
(use-package! lsp-nix
:ensure lsp-mode
:after
(lsp-mode)
:demand t
:custom
(lsp-nix-nil-formatter
["alejandra"]))
(use-package! nushell-mode
:config
(setq nushell-enable-auto-indent 1))
(after! vterm
(setq vterm-shell "nu")) ; use nushell by defualt
;; emacs-rime
(use-package! rime
:custom
(default-input-method "rime")
(rime-librime-root "~/.local/share/emacs/librime"))
;; use parinfer for lisp editing
(use-package! parinfer-rust-mode
:hook ((emacs-lisp-mode
clojure-mode
scheme-mode
lisp-mode
racket-mode
fennel-mode
hy-mode) . parinfer-rust-mode)
:init
;; parinfer-rust library do not provide a apple silicon binary.
;; fix: https://github.com/doomemacs/doomemacs/issues/6163
(setq parinfer-rust-auto-download 0)
;; we need to download it manually and put it in this path
(setq parinfer-rust-library "~/.local/share/emacs/parinfer-rust/parinfer-rust.so")
:config
(map! :map parinfer-rust-mode-map
:localleader
"p" #'parinfer-rust-switch-mode
"P" #'parinfer-rust-toggle-disable))
;; disable smatparens-mode here to void conflict with parinfer
;; https://discourse.doomemacs.org/t/disable-smartparens-or-parenthesis-completion/134
(add-hook 'clojure-mode-hook #'turn-off-smartparens-mode)
(add-hook 'scheme-mode-hook #'turn-off-smartparens-mode)
(add-hook 'lisp-mode-hook #'turn-off-smartparens-mode)
(add-hook 'racket-mode-hook #'turn-off-smartparens-mode)
(add-hook 'fennel-mode-hook #'turn-off-smartparens-mode)
(add-hook 'hy-mode-hook #'turn-off-smartparens-mode)
;; auto-save
(use-package super-save
:ensure t
:config
(super-save-mode +1)
(setq super-save-auto-save-when-idle t)
(setq auto-save-default nil))
;; save on find-file
(add-to-list 'super-save-hook-triggers 'find-file-hook)
(use-package! copilot
:hook
(prog-mode . copilot-mode)
:bind
(:map copilot-completion-map
("<tab>" . 'copilot-accept-completion)
("TAB" . 'copilot-accept-completion)
("C-TAB" . 'copilot-accept-completion-by-word)
("C-<tab>" . 'copilot-accept-completion-by-word))
:config
(copilot-mode +1))
(use-package! wakatime-mode :ensure t)
+211
View File
@@ -0,0 +1,211 @@
;;; init.el -*- lexical-binding: t; -*-
;; This file controls what Doom modules are enabled and what order they load
;; in. Remember to run 'doom sync' after modifying it!
;; NOTE Press 'SPC h d h' (or 'C-h d h' for non-vim users) to access Doom's
;; documentation. There you'll find a link to Doom's Module Index where all
;; of our modules are listed, including what flags they support.
;; NOTE Move your cursor over a module's name (or its flags) and press 'K' (or
;; 'C-c c k' for non-vim users) to view its documentation. This works on
;; flags as well (those symbols that start with a plus).
;;
;; Alternatively, press 'gd' (or 'C-c c d') on a module to browse its
;; directory (for easy access to its source code).
(doom! :input
;;bidi ; (tfel ot) thgir etirw uoy gnipleh
chinese
;;japanese
;;layout ; auie,ctsrnm is the superior home row
:completion
;; (company +childframe) ; conflict with lsp-bridge
; the ultimate code completion backend
;;helm ; the *other* search engine for love and life
;;ido ; the other *other* search engine...
;;ivy ; a search engine for love and life
vertico ; the search engine of the future
:ui
;;deft ; notational velocity for Emacs
doom ; what makes DOOM look the way it does
doom-dashboard ; a nifty splash screen for Emacs
;;doom-quit ; DOOM quit-message prompts when you quit Emacs
;; (emoji +unicode) ; Emacs 29 provides native support for inserting Unicode emojis.
; 🙂
hl-todo ; highlight TODO/FIXME/NOTE/DEPRECATED/HACK/REVIEW
indent-guides ; highlighted indent columns
ligatures ; ligatures and symbols to make your code pretty again
modeline ; snazzy, Atom-inspired modeline, plus API
ophints ; highlight the region an operation acts on
(popup +defaults)
; tame sudden yet inevitable temporary windows
tabs ; a tab bar for Emacs
treemacs ; a project drawer, like neotree but cooler
unicode ; extended unicode support for various languages
(vc-gutter +pretty)
; vcs diff in the fringe
vi-tilde-fringe ; fringe tildes to mark beyond EOB
;;window-select ; visually switch windows
workspaces ; tab emulation, persistence & separate workspaces
;;zen ; distraction-free coding or writing
:editor
(evil +everywhere)
; come to the dark side, we have cookies
file-templates ; auto-snippets for empty files
fold ; (nigh) universal code folding
(format +onsave)
; automated prettiness
;; multiple-cursors ; editing in many places at once
;; objed ; text object editing for the innocent, conflict with parinfer
parinfer ; turn lisp into python, sort of, conflict with copilot/objed/smartparens
;;rotate-text ; cycle region at point between text candidates
snippets ; my elves. They type so I don't have to
word-wrap ; soft wrapping with language-aware indent
:emacs
dired ; making dired pretty [functional]
electric ; smarter, keyword-based electric-indent
ibuffer ; interactive buffer management
undo ; persistent, smarter undo for your inevitable mistakes
vc ; version-control and Emacs, sitting in a tree
:term
;;eshell ; the elisp shell that works everywhere
;;shell ; simple shell REPL for Emacs
;;term ; basic terminal emulator for Emacs
vterm ; the best terminal emulation in Emacs
:checkers
syntax ; tasing you for every semicolon you forget
(spell +flyspell)
; tasing you for misspelling mispelling
grammar ; tasing grammar mistake every you make
:tools
;;ansible
;;biblio ; Writes a PhD for you (citation needed)
;;collab ; buffers with friends
;;debugger ; FIXME stepping through code, to help you add bugs
;;direnv
(docker)
editorconfig ; let someone else argue about tabs vs spaces
;;ein ; tame Jupyter notebooks with emacs
(eval +overlay)
; run code, run (also, repls)
lookup ; navigate your code and its documentation
lsp ; lsp-mode, conflict with lsp-bridge
magit ; a git porcelain for Emacs
;;make ; run make tasks from Emacs
;;pass ; password manager for nerds
pdf ; pdf enhancements
;;prodigy ; FIXME managing external services & code builders
(terraform)
; infrastructure as code
tree-sitter ; syntax and parsing, sitting in a tree...
;;upload ; map local to remote projects via ssh/ftp
:os
(:if IS-MAC macos)
; improve compatibility with macOS
tty ; improve the terminal Emacs experience
:lang
;;agda ; types of types of types of types...
;;beancount ; mind the GAAP
(cc +lsp +tree-sitter)
; C > C++ == 1
;;clojure ; java with a lisp
;;common-lisp ; if you've seen one lisp, you've seen them all
;;coq ; proofs-as-programs
;;crystal ; ruby at the speed of c
;;csharp ; unity, .NET, and mono shenanigans
data ; config/data formats
;;(dart +flutter) ; paint ui and not much else
;;dhall
;;elixir ; erlang done right
;;elm ; care for a cup of TEA?
emacs-lisp ; drown in parentheses
;;erlang ; an elegant language for a more civilized age
;;ess ; emacs speaks statistics
;;factor
;;faust ; dsp, but you get to keep your soul
;;fortran ; in FORTRAN, GOD is REAL (unless declared INTEGER)
;;fsharp ; ML stands for Microsoft's Language
;;fstar ; (dependent) types and (monadic) effects and Z3
;;gdscript ; the language you waited for
(go +lsp +tree-sitter) ;; disable go-mode, use lsp-bridge instead
; the hipster dialect
;;(graphql) ; Give queries a REST
;;(haskell) ; a language that's lazier than I am
;;hy ; readability of scheme w/ speed of python
;;idris ; a language you can depend on
(json +lsp +tree-sitter)
; At least it ain't XML
(java +lsp +tree-sitter)
; the poster child for carpal tunnel syndrome
(javascript +lsp +tree-sitter)
; all(hope(abandon(ye(who(enter(here))))))
;;julia ; a better, faster MATLAB
;;kotlin ; a better, slicker Java(Script)
(latex)
; writing papers in Emacs has never been so fun
;;lean ; for folks with too much to prove
;;ledger ; be audit you can be
(lua +lsp +tree-sitter)
; one-based indices? one-based indices
(markdown +grip)
; writing docs for people to ignore
;;nim ; python + lisp at the speed of c
(nix +lsp +tree-sitter)
; I hereby declare "nix geht mehr!"
;;ocaml ; an objective camel
(org +pandoc +hugo +jupyter) ; organize your plain life in plain text
;;php ; perl's insecure younger brother
;;plantuml ; diagrams for confusing people more
;;purescript ; javascript, but functional
(python +lsp +tree-sitter +pyright)
; beautiful is better than ugly
;;qt ; the 'cutest' gui framework ever
racket ; a DSL for DSLs
;;raku ; the artist formerly known as perl6
;;rest ; Emacs as a REST client
;;rst ; ReST in peace
;;(ruby +rails) ; 1.step {|i| p "Ruby is #{i.even? ? 'love' : 'life'}"}
(rust +lsp +tree-sitter)
; Fe2O3.unwrap().unwrap().unwrap().unwrap()
;;scala ; java, but good
(scheme +guile)
; a fully conniving family of lisps
(sh +lsp +tree-sitter)
; she sells {ba,z,fi}sh shells on the C xor
;;sml
;;solidity ; do you need a blockchain? No.
;;swift ; who asked for emoji variables?
;;terra ; Earth and Moon in alignment for performance.
(web +lsp +tree-sitter)
; support for various web languages, including HTML5, CSS, SASS/SCSS, Pug/Jade/Slim, and more
(yaml +lsp +tree-sitter)
; JSON, but readable
;;zig ; C, but simpler
:email
;;(mu4e +org +gmail)
;;notmuch
;;(wanderlust +gmail)
:app
;;calendar
;;emms
;;everywhere ; *leave* Emacs!? You must be joking
;;irc ; how neckbeards socialize
;;(rss +org) ; emacs as an RSS reader
;;twitter ; twitter client https://twitter.com/vnought
:config
;;literate
(default +bindings +smartparens))
@@ -0,0 +1,64 @@
;; -*- no-byte-compile: t; -*-
;;; $DOOMDIR/packages.el
;; To install a package with Doom you must declare them here and run 'doom sync'
;; on the command line, then restart Emacs for the changes to take effect -- or
;; use 'M-x doom/reload'.
(package! super-save)
(package! rime)
(package! wakatime-mode
:recipe
(:host github :repo "wakatime/wakatime-mode" :files
("*.el" "dist")))
(package! nushell-mode :recipe
(:host github :repo "mrkkrp/nushell-mode"))
(package! copilot
:recipe
(:host github :repo "copilot-emacs/copilot.el" :files
("*.el" "dist")))
;; To install SOME-PACKAGE from MELPA, ELPA or emacsmirror:
;; (package! some-package)
;; To install a package directly from a remote git repo, you must specify a
;; `:recipe'. You'll find documentation on what `:recipe' accepts here:
;; https://github.com/radian-software/straight.el#the-recipe-format
;; (package! another-package
;; :recipe (:host github :repo "username/repo"))
;; If the package you are trying to install does not contain a PACKAGENAME.el
;; file, or is located in a subdirectory of the repo, you'll need to specify
;; `:files' in the `:recipe':
;; (package! this-package
;; :recipe (:host github :repo "username/repo"
;; :files ("some-file.el" "src/lisp/*.el")))
;; If you'd like to disable a package included with Doom, you can do so here
;; with the `:disable' property:
;; (package! builtin-package :disable t)
;; You can override the recipe of a built in package without having to specify
;; all the properties for `:recipe'. These will inherit the rest of its recipe
;; from Doom or MELPA/ELPA/Emacsmirror:
;; (package! builtin-package :recipe (:nonrecursive t))
;; (package! builtin-package-2 :recipe (:repo "myfork/package"))
;; Specify a `:branch' to install a package from a particular branch or tag.
;; This is required for some packages whose default branch isn't 'master' (which
;; our package manager can't deal with; see radian-software/straight.el#279)
;; (package! builtin-package :recipe (:branch "develop"))
;; Use `:pin' to specify a particular commit to install.
;; (package! builtin-package :pin "1a2b3c4d5e")
;; Doom's packages are pinned to a specific commit and updated from release to
;; release. The `unpin!' macro allows you to unpin single packages...
;; (unpin! pinned-package)
;; ...or multiple packages
;; (unpin! pinned-package another-pinned-package)
;; ...Or *all* packages (NOT RECOMMENDED; will likely break things)
;; (unpin! t)
+43
View File
@@ -0,0 +1,43 @@
# Helix Editor
Neovim is really powerful, and have a very active community. I use it as my main editor, and I'm very happy with it. I use it for everything, from writing code to writing this document.
But its configuration is a bit complex, and finding the right plugins, writing configurations, and keeping everything up to date is not easy.
That's why I'm interested in Helix, Helix is similar to Neovim, but it's more opinionated, and it's batteries included.
Whether I'll switch my main editor to Helix or not, it gives me a lot of ideas on how to improve my Neovim workflow.
## Tutorial
Use `:tutor` in helix to start the tutorial.
## Differences between Neovim and Helixer
1. Selecting first, then action.
1. Helix: delete 2 word: `2w` then `x`. You can always see what you're selecting before you apply the action.
2. Neovim: delete 2 word: `d`. then `2w`. No visual feedback before you apply the action.
1. Helix - Morden builtin features: LSP, tree-sitter, fuzzy finder, multi cursors, surround and more.
1. They're all available in Neovim too, but you need to find and use the right plugins manually, which takes time and effort.
1. Helix is built in Rust from scratch. The result is a much smaller codebase and a modern set of defaults. No VimScript. No Lua.
1. Neovim contains a lot of VimScript, and lua is too dynamic, it's hard to debug.
1. Personally I'm glad to take a look at a Rust codebase, but not a VimScript/Lua codebase.
1. Neovim have a very activate plugin ecosystem, and it's easy to find plugins for almost everything.
1. Helix is still new, and it even do have a stable plugin system yet. A PR to add a plugin system is still envolving: <https://github.com/helix-editor/helix/pull/8675>
2. Neovim has intergrated terminal, and it's very powerful. It's quite similar to VSCode's intergrated terminal. I use it a lot.
1. Helix doesn't have a intergrated terminal yet, as it's complicated to implement. Users are recommended to use tmux/Zellij or Wezterm/Kitty to implement this feature instead.
1. <https://github.com/helix-editor/helix/issues/1976#issuecomment-1091074719>
1. <https://github.com/helix-editor/helix/pull/4649>
1. **My Neovim often gets stuck when I switch to [toggleterm.nvim](https://github.com/akinsho/toggleterm.nvim), this Helix issue made me consider to switch from this Neovim plugin to Zellij**.
1. Helix do not have a tree-view panel, it's recommended to use Yazi/ranger/Broot instead, and open Helix in them.
1. a tree-view plugin may be added after the plugin system is stable, but no one knows when it will be.
2. and some Helix users stated that they don't need a tree-view plugin, Helix's file picker is useful and good enough.
1. It seems Helix lacks a global substitution command, you should run it in another window(via wm or Zellij).
1. <https://github.com/helix-editor/helix/issues/196>
1. Neovim's substitution command allow you to preview the changes before you apply it, and it's very useful. if I switch to Helix, I'll need to find some other tools with similar feature(such as https://github.com/ms-jpq/sad).
1. Complexity and Maintenance Costs vs Batteries Included: <https://github.com/helix-editor/helix/discussions/6356>
I think Use Helix/Neovim within a terminal file manager(Yazi/ranger/Broot) and Zellij is a good idea.
It's quite different from the workflow I migrated from VSCode/JetBrains before, I'm very interested in it.
In Neovim I can make the workflow similar to VSCode/JetBrains by using some plugins, but Helix forces me to get out of my comfort zone, and try something new.
+36
View File
@@ -0,0 +1,36 @@
{
pkgs,
nur-ryan4yin,
...
}: {
# https://github.com/catppuccin/helix
xdg.configFile."helix/themes".source = "${nur-ryan4yin.packages.${pkgs.system}.catppuccin-helix}/themes/default";
programs.helix = {
enable = true;
package = pkgs.helix;
settings = {
theme = "catppuccin_mocha";
editor = {
line-number = "relative";
cursorline = true;
color-modes = true;
lsp.display-messages = true;
cursor-shape = {
insert = "bar";
normal = "block";
select = "underline";
};
indent-guides.render = true;
};
keys.normal = {
space = {
space = "file_picker";
w = ":w";
q = ":q";
};
esc = ["collapse_selection" "keep_primary_selection"];
};
};
};
}
+176
View File
@@ -0,0 +1,176 @@
# Neovim Editor
My Neovim config based on [AstroNvim](https://github.com/AstroNvim/AstroNvim).
For more details, visit the [AstroNvim website](https://astronvim.com/).
This document outlines neovim's configuration structure and various shortcuts/commands for efficient usage.
## Screenshots
![](/_img/astronvim_2023-07-13_00-39.webp)
![](/_img/hyprland_2023-07-29_2.webp)
## Configuration Structure
| Description | Standard Location | My Location |
| ------------------------------------------------- | ------------------------------------------- | ------------------------------------------------------------------------- |
| Neovim's config | `~/.config/nvim` | AstroNvim's github repository, referenced as a flake input in this flake. |
| AstroNvim's user configuration | `$XDG_CONFIG_HOME/astronvim/lua/user` | [./astronvim_user/](./astronvim_user/) |
| Plugins installation directory (lazy.nvim) | `~/.local/share/nvim/` | The same as standard location, generated and managed by lazy.nvim. |
| LSP servers, DAP servers, linters, and formatters | `~/.local/share/nvim/mason/`(by mason.nvim) | [./default.nix](./default.nix), installed by nix. |
## Update/Clean Plugins
Note that lazy.nvim will not automatically update plugins, so you need to update them manually.
```bash
:Lazy update
```
Remove all unused plugins:
```bash
:Lazy clean
```
## Testing
> via `Justfile` located at the root of this repo.
```bash
# testing
just nvim-test
# clear test data
just nvim-clear
```
## Cheetsheet
Here is the cheetsheet related to my Neovim configs. Please read vim's common cheetsheet at [../README.md](../README.md) before reading the following.
### Incremental Selection
Provided by nvim-treesitter.
| Action | Shortcut |
| ----------------- | -------------- |
| init selection | `<Ctrl-space>` |
| node incremental | `<Ctrl-space>` |
| scope incremental | `<Alt-Space>` |
| node decremental | `Backspace` |
### Search and Jump
Provided by [flash.nvim](https://github.com/folke/flash.nvim), it's a intelligent search and jump plugin.
1. It enhaces the default search and jump behavior of neovim.(search with prefix `/`)
| Action | Shortcut |
| ----------------- | ------------------------------------------------------------------------------------------------------------- |
| Search | `/`(normal search), `s`(disable all code highlight, only highlight matches) |
| Treesitter Search | `yR`,`dR`, `cR`, `vR`, `ctrl+v+R`(arround your matches, all the surrounding Treesitter nodes will be labeled) |
| Remote Flash | `yr`, `dr`, `cr`, (arround your matches, all the surrounding Treesitter nodes will be labeled) |
### Commands & Shortcuts
| Action | Shortcut |
| ----------------------------- | -------------- |
| Open file explorer | `<Space> + e` |
| Focus Neotree to current file | `<Space> + o` |
| Toggle line wrap | `<Space> + uw` |
| Show line diagnostics | `gl` |
| Show function/variable info | `K` |
| References of a symbol | `gr` |
### Window Navigation
- Switch between windows: `<Ctrl> + h/j/k/l`
- Resize windows: `<Ctrl> + Up/Down/Left/Right`
- Note: On macOS, conflicts with system shortcuts
- Disable in System Preferences -> Keyboard -> Shortcuts -> Mission Control
### Splitting and Buffers
|
| Action | Shortcut |
| --------------------- | ------------- |
| Horizontal Split | `\` |
| Vertical Split | `\|` |
| Close Buffer | `<Space> + c` |
### Editing and Formatting
| Action | Shortcut |
| ----------------------------------------------------- | -------------- |
| Toggle buffer auto formatting | `<Space> + uf` |
| Format Document | `<Space> + lf` |
| Code Actions | `<Space> + la` |
| Rename | `<Space> + lr` |
| Opening LSP symbols | `<Space> + lS` |
| Comment Line(support multiple lines) | `<Space> + /` |
| Open filepath/URL at cursor(neovim's builtin command) | `gx` |
| Find files by name (fzf) | `<Space> + ff` |
| Grep string in files (ripgrep) | `<Space> + fw` |
### Sessions
| Action | Shortcut |
| ------------------------------ | -------------- |
| Save Session | `<Space> + Ss` |
| Last Session | `<Space> + Sl` |
| Delete Session | `<Space> + Sd` |
| Search Session | `<Space> + Sf` |
| Load Current Directory Session | `<Space> + S.` |
### Debugging
Press `<Space> + D` to view available bindings and options.
### Search and Replace Globally
| Description | Shortcut |
| ------------------------------------------------------------ | ---------------------------------------------------------------- |
| Open spectre.nvim search and replace panel | `<Space> + ss` |
Search and replace via cli(fd + sad + delta):
```bash
fd "\\.nix$" . | sad '<pattern>' '<replacement>' | delta
```
### Surrounding Characters
Provided by mini.surround plugin.
- Prefix `gz`
| Action | Shortcut | Description |
| ------------------------------ | -------- | ----------------------------------------------- |
| Add surrounding characters | `gzaiw'` | Add `'` around the word under cursor |
| Delete surrounding characters | `gzd'` | Delete `'` around the word under cursor |
| Replace surrounding characters | `gzr'"` | Replace `'` by `"` around the word under cursor |
| Highlight surrounding | `gzh'` | Highlight `'` around the word under cursor |
### Text Manipulation
| Action | |
| -------------------------------------- | ------------- |
| Join with LSP intelligence(treesj) | `<Space> + j` |
| Split Line into Multiple Lines(treesj) | `<Space> + s` |
### Miscellaneous
| Action | |
| --------------------- | --------------- |
| Show all Yank History | `:<Space> + yh` |
| Show undo history | `:<Space> + uh` |
## Additional Resources
For more detailed information and advanced usage, refer to:
1. [AstroNvim walkthrough](https://astronvim.com/Basic%20Usage/walkthrough)
2. [./astronvim_user/mapping.lua](./astronvim_user/mappings.lua)
3. All the plugins' documentations
@@ -0,0 +1,2 @@
.clj-kondo/
.nrepl-port
@@ -0,0 +1 @@
{:source-file-patterns ["*.fnl" "**/*.fnl"]}
@@ -0,0 +1,7 @@
column_width = 120
line_endings = "Unix"
indent_type = "Spaces"
indent_width = 2
quote_style = "AutoPreferDouble"
call_parentheses = "None"
collapse_simple_statement = "Always"
@@ -0,0 +1,579 @@
return {
colorscheme = "catppuccin",
options = {
opt = {
relativenumber = true, -- Show relative numberline
signcolumn = "auto", -- Show sign column when used only
spell = false, -- Spell checking
swapfile = false, -- Swapfile
smartindent = false, -- fix https://github.com/ryan4yin/nix-config/issues/4
title = true, -- Set the title of window to `filename [+=-] (path) - NVIM`
-- The percentage of 'columns' to use for the title
-- When the title is longer, only the end of the path name is shown.
titlelen = 20,
},
},
plugins = {
"AstroNvim/astrocommunity",
-- Motion
{ import = "astrocommunity.motion.mini-surround" },
-- https://github.com/echasnovski/mini.ai
{ import = "astrocommunity.motion.mini-ai" },
{ import = "astrocommunity.motion.flash-nvim" },
-- diable toggleterm.nvim, zellij's terminal is far better than neovim's one
{ "akinsho/toggleterm.nvim", enabled = false },
{ "folke/flash.nvim", vscode = false },
-- Highly experimental plugin that completely replaces
-- the UI for messages, cmdline and the popupmenu.
-- { import = "astrocommunity.utility.noice-nvim" },
-- Fully featured & enhanced replacement for copilot.vim
-- <Tab> work with both auto completion in cmp and copilot
{ import = "astrocommunity.media.vim-wakatime" },
{ import = "astrocommunity.motion.leap-nvim" },
{ import = "astrocommunity.motion.flit-nvim" },
{ import = "astrocommunity.scrolling.nvim-scrollbar" },
{ import = "astrocommunity.editing-support.todo-comments-nvim" },
-- Language Support
---- Frontend & NodeJS
{ import = "astrocommunity.pack.typescript-all-in-one" },
{ import = "astrocommunity.pack.tailwindcss" },
{ import = "astrocommunity.pack.html-css" },
{ import = "astrocommunity.pack.prisma" },
{ import = "astrocommunity.pack.vue" },
---- Configuration Language
{ import = "astrocommunity.pack.markdown" },
{ import = "astrocommunity.pack.json" },
{ import = "astrocommunity.pack.yaml" },
{ import = "astrocommunity.pack.toml" },
---- Backend / System
{ import = "astrocommunity.pack.lua" },
{ import = "astrocommunity.pack.go" },
{ import = "astrocommunity.pack.rust" },
{ import = "astrocommunity.pack.python" },
{ import = "astrocommunity.pack.java" },
{ import = "astrocommunity.pack.cmake" },
{ import = "astrocommunity.pack.cpp" },
-- { import = "astrocommunity.pack.nix" }, -- manually add config for nix, comment this one.
{ import = "astrocommunity.pack.proto" },
---- Operation & Cloud Native
{ import = "astrocommunity.pack.terraform" },
{ import = "astrocommunity.pack.bash" },
{ import = "astrocommunity.pack.docker" },
{ import = "astrocommunity.pack.helm" },
-- colorscheme
{ import = "astrocommunity.colorscheme.catppuccin" },
{
"catppuccin/nvim",
name = "catppuccin",
opts = function(_, opts)
opts.flavour = "mocha" -- latte, frappe, macchiato, mocha
opts.transparent_background = true -- setting the background color.
end,
},
-- Language Parser for syntax highlighting / indentation / folding / Incremental selection
{
"nvim-treesitter/nvim-treesitter",
opts = function(_, opts)
local utils = require("astronvim.utils")
opts.incremental_selection = {
enable = true,
keymaps = {
init_selection = "<C-space>", -- Ctrl + Space
node_incremental = "<C-space>",
scope_incremental = "<A-space>", -- Alt + Space
node_decremental = "<bs>", -- Backspace
},
}
opts.ignore_install = { "gotmpl" }
opts.ensure_installed = utils.list_insert_unique(opts.ensure_installed, {
-- neovim
"vim",
"lua",
-- operation & cloud native
"dockerfile",
"hcl",
"jsonnet",
"regex",
"terraform",
"nix",
"csv",
-- other programming language
"diff",
"gitignore",
"gitcommit",
"latex",
"sql",
-- Lisp like
"fennel",
"clojure",
"commonlisp",
-- customized languages:
"scheme",
})
-- add support for scheme
local parser_config = require("nvim-treesitter.parsers").get_parser_configs()
parser_config.scheme = {
install_info = {
url = "https://github.com/6cdh/tree-sitter-scheme", -- local path or git repo
files = { "src/parser.c" },
-- optional entries:
branch = "main", -- default branch in case of git repo if different from master
generate_requires_npm = false, -- if stand-alone parser without npm dependencies
requires_generate_from_grammar = false, -- if folder contains pre-generated src/parser.c
},
}
-- use scheme parser for filetypes: scm
vim.treesitter.language.register("scheme", "scm")
end,
},
{
"eraserhd/parinfer-rust",
build = "cargo build --release",
ft = { "scm", "scheme" },
},
{ "Olical/nfnl", ft = "fennel" },
{
"Olical/conjure",
ft = { "clojure", "fennel", "python", "scheme" }, -- etc
-- [Optional] cmp-conjure for cmp
dependencies = {
{
"PaterJason/cmp-conjure",
config = function()
local cmp = require("cmp")
local config = cmp.get_config()
table.insert(config.sources, {
name = "buffer",
option = {
sources = {
{ name = "conjure" },
},
},
})
cmp.setup(config)
end,
},
},
config = function(_, opts)
require("conjure.main").main()
require("conjure.mapping")["on-filetype"]()
end,
init = function()
-- Set configuration options here
vim.g["conjure#debug"] = true
end,
},
{
"nvim-orgmode/orgmode",
dependencies = {
{ "nvim-treesitter/nvim-treesitter", lazy = true },
},
event = "VeryLazy",
config = function()
-- Load treesitter grammar for org
require("orgmode").setup_ts_grammar()
-- Setup treesitter
require("nvim-treesitter.configs").setup({
highlight = {
enable = true,
additional_vim_regex_highlighting = { "org" },
},
ensure_installed = { "org" },
})
-- Setup orgmode
require("orgmode").setup({
org_agenda_files = "~/org/**/*",
org_default_notes_file = "~/org/refile.org",
})
end,
},
-- Lua implementation of CamelCaseMotion, with extra consideration of punctuation.
{ import = "astrocommunity.motion.nvim-spider" },
-- AI Assistant
{ import = "astrocommunity.completion.copilot-lua-cmp" },
-- Custom copilot-lua to enable filtypes: markdown
{
"zbirenbaum/copilot.lua",
opts = function(_, opts)
opts.filetypes = {
yaml = true,
markdown = true,
}
end,
},
{
"0x00-ketsu/autosave.nvim",
-- lazy-loading on events
event = { "InsertLeave", "TextChanged" },
opts = function(_, opts)
opts.prompt_style = "stdout" -- notify or stdout
end,
},
-- markdown preview
{
"0x00-ketsu/markdown-preview.nvim",
ft = { "md", "markdown", "mkd", "mkdn", "mdwn", "mdown", "mdtxt", "mdtext", "rmd", "wiki" },
config = function()
require("markdown-preview").setup({
-- your configuration comes here
-- or leave it empty to use the default settings
-- refer to the setup section below
})
end,
},
-- clipboard manager
{
"gbprod/yanky.nvim",
opts = function()
local mapping = require("yanky.telescope.mapping")
local mappings = mapping.get_defaults()
mappings.i["<c-p>"] = nil
return {
highlight = { timer = 200 },
picker = {
telescope = {
use_default_mappings = false,
mappings = mappings,
},
},
}
end,
keys = {
{
"y",
"<Plug>(YankyYank)",
mode = { "n", "x" },
desc = "Yank text",
},
{
"p",
"<Plug>(YankyPutAfter)",
mode = { "n", "x" },
desc = "Put yanked text after cursor",
},
{
"P",
"<Plug>(YankyPutBefore)",
mode = { "n", "x" },
desc = "Put yanked text before cursor",
},
{
"gp",
"<Plug>(YankyGPutAfter)",
mode = { "n", "x" },
desc = "Put yanked text after selection",
},
{
"gP",
"<Plug>(YankyGPutBefore)",
mode = { "n", "x" },
desc = "Put yanked text before selection",
},
{ "[y", "<Plug>(YankyCycleForward)", desc = "Cycle forward through yank history" },
{ "]y", "<Plug>(YankyCycleBackward)", desc = "Cycle backward through yank history" },
{ "]p", "<Plug>(YankyPutIndentAfterLinewise)", desc = "Put indented after cursor (linewise)" },
{ "[p", "<Plug>(YankyPutIndentBeforeLinewise)", desc = "Put indented before cursor (linewise)" },
{ "]P", "<Plug>(YankyPutIndentAfterLinewise)", desc = "Put indented after cursor (linewise)" },
{ "[P", "<Plug>(YankyPutIndentBeforeLinewise)", desc = "Put indented before cursor (linewise)" },
{ ">p", "<Plug>(YankyPutIndentAfterShiftRight)", desc = "Put and indent right" },
{ "<p", "<Plug>(YankyPutIndentAfterShiftLeft)", desc = "Put and indent left" },
{ ">P", "<Plug>(YankyPutIndentBeforeShiftRight)", desc = "Put before and indent right" },
{ "<P", "<Plug>(YankyPutIndentBeforeShiftLeft)", desc = "Put before and indent left" },
{ "=p", "<Plug>(YankyPutAfterFilter)", desc = "Put after applying a filter" },
{ "=P", "<Plug>(YankyPutBeforeFilter)", desc = "Put before applying a filter" },
},
},
-- Enhanced matchparen.vim plugin for Neovim to highlight the outer pair.
{
"utilyre/sentiment.nvim",
version = "*",
event = "VeryLazy", -- keep for lazy loading
opts = {
-- config
},
init = function()
-- `matchparen.vim` needs to be disabled manually in case of lazy loading
vim.g.loaded_matchparen = 1
end,
},
-- joining blocks of code into oneline, or splitting one line into multiple lines.
{
"Wansmer/treesj",
keys = { "<space>m", "<space>j", "<space>s" },
dependencies = { "nvim-treesitter/nvim-treesitter" },
config = function()
require("treesj").setup({ --[[ your config ]]
})
end,
},
-- File explorer(Custom configs)
{
"nvim-neo-tree/neo-tree.nvim",
opts = {
filesystem = {
filtered_items = {
visible = true, -- visible by default
hide_dotfiles = false,
hide_gitignored = false,
},
},
},
},
-- The plugin offers the alibity to refactor code.
{
"ThePrimeagen/refactoring.nvim",
dependencies = {
{ "nvim-lua/plenary.nvim" },
{ "nvim-treesitter/nvim-treesitter" },
},
},
-- The plugin offers the abilibty to search and replace.
{
"nvim-pack/nvim-spectre",
dependencies = {
{ "nvim-lua/plenary.nvim" },
},
},
-- full signature help, docs and completion for the nvim lua API.
{ "folke/neodev.nvim", opts = {} },
-- automatically highlighting other uses of the word under the cursor using either LSP, Tree-sitter, or regex matching.
{ "RRethy/vim-illuminate", config = function() end },
-- implementation/definition preview
{
"rmagatti/goto-preview",
config = function()
require("goto-preview").setup({})
end,
},
-- Undo tree
{ "debugloop/telescope-undo.nvim" },
-- Install lsp, formmatter and others via home manager instead of Mason.nvim
-- LSP installations
{
"williamboman/mason-lspconfig.nvim",
-- mason is unusable on NixOS, disable it.
-- ensure_installed nothing
opts = function(_, opts)
opts.ensure_installed = nil
opts.automatic_installation = false
end,
},
-- Formatters/Linter installation
{
"jay-babu/mason-null-ls.nvim",
-- mason is unusable on NixOS, disable it.
-- ensure_installed nothing
opts = function(_, opts)
opts.ensure_installed = nil
opts.automatic_installation = false
end,
},
-- Debugger installation
{
"jay-babu/mason-nvim-dap.nvim",
-- mason is unusable on NixOS, disable it.
-- ensure_installed nothing
opts = function(_, opts)
opts.ensure_installed = nil
opts.automatic_installation = false
end,
},
{
"jose-elias-alvarez/null-ls.nvim",
opts = function(_, opts)
local null_ls = require("null-ls")
local code_actions = null_ls.builtins.code_actions
local diagnostics = null_ls.builtins.diagnostics
local formatting = null_ls.builtins.formatting
local hover = null_ls.builtins.hover
local completion = null_ls.builtins.completion
-- https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/doc/BUILTINS.md
if type(opts.sources) == "table" then
vim.list_extend(opts.sources, {
-- Common Code Actions
code_actions.gitsigns,
-- common refactoring actions based off the Refactoring book by Martin Fowler
code_actions.refactoring,
code_actions.gomodifytags, -- Go - modify struct field tags
code_actions.impl, -- Go - generate interface method stubs
code_actions.shellcheck,
code_actions.proselint, -- English prose linter
code_actions.statix, -- Lints and suggestions for Nix.
-- Diagnostic
diagnostics.actionlint, -- GitHub Actions workflow syntax checking
diagnostics.buf, -- check text in current buffer
diagnostics.checkmake, -- check Makefiles
diagnostics.deadnix, -- Scan Nix files for dead code.
-- Formatting
formatting.prettier, -- js/ts/vue/css/html/json/... formatter
diagnostics.hadolint, -- Dockerfile linter
formatting.black, -- Python formatter
formatting.ruff, -- extremely fast Python linter
formatting.goimports, -- Go formatter
formatting.shfmt, -- Shell formatter
formatting.rustfmt, -- Rust formatter
formatting.taplo, -- TOML formatteautoindentr
formatting.terraform_fmt, -- Terraform formatter
formatting.stylua, -- Lua formatter
formatting.alejandra, -- Nix formatter
formatting.sqlfluff.with({ -- SQL formatter
extra_args = { "--dialect", "postgres" }, -- change to your dialect
}),
formatting.nginx_beautifier, -- Nginx formatter
formatting.verible_verilog_format, -- Verilog formatter
formatting.emacs_scheme_mode, -- using emacs in batch mode to format scheme files.
formatting.fnlfmt, -- Format Fennel code
})
end
end,
},
{
"nvim-telescope/telescope.nvim",
branch = "0.1.x",
dependencies = { "nvim-lua/plenary.nvim" },
init = function()
-- 1. Disable highlighting for certain filetypes
-- 2. Ignore files larger than a certain filesize
local previewers = require("telescope.previewers")
local _bad = { ".*%.csv", ".*%.min.js" } -- Put all filetypes that slow you down in this array
local filesize_threshold = 300 * 1024 -- 300KB
local bad_files = function(filepath)
for _, v in ipairs(_bad) do
if filepath:match(v) then
return false
end
end
return true
end
local new_maker = function(filepath, bufnr, opts)
opts = opts or {}
if opts.use_ft_detect == nil then
opts.use_ft_detect = true
end
-- 1. Check if the file is in the bad_files array, and if so, don't highlight it
opts.use_ft_detect = opts.use_ft_detect == false and false or bad_files(filepath)
-- 2. Check the file size, and ignore it if it's too big(preview nothing).
filepath = vim.fn.expand(filepath)
vim.loop.fs_stat(filepath, function(_, stat)
if not stat then
return
end
if stat.size > filesize_threshold then
return
else
previewers.buffer_previewer_maker(filepath, bufnr, opts)
end
end)
end
require("telescope").setup({
defaults = {
buffer_previewer_maker = new_maker,
},
})
end,
},
},
-- Configure require("lazy").setup() options
lazy = {
defaults = { lazy = true },
performance = {
rtp = {
-- customize default disabled vim plugins
disabled_plugins = {},
},
},
},
-- https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md
lsp = {
config = {
-- the offset_enconding of clangd will confilicts whit null-ls
-- so we need to manually set it to utf-8
clangd = {
capabilities = {
offsetEncoding = "utf-8",
},
},
scheme_langserver = {
filetypes = { "scheme", "scm" },
single_file_support = true,
},
},
-- enable servers that installed by home-manager instead of mason
servers = {
---- Frontend & NodeJS
"tsserver", -- typescript/javascript language server
"tailwindcss", -- tailwindcss language server
"html", -- html language server
"cssls", -- css language server
"prismals", -- prisma language server
"volar", -- vue language server
---- Configuration Language
"marksman", -- markdown ls
"jsonls", -- json language server
"yamlls", -- yaml language server
"taplo", -- toml language server
---- Backend
"lua_ls", -- lua
"gopls", -- go
"rust_analyzer", -- rust
"pyright", -- python
"ruff_lsp", -- extremely fast Python linter and code transformation
"jdtls", -- java
"nil_ls", -- nix language server
"bufls", -- protocol buffer language server
"zls", -- zig language server
---- HDL
"verible", -- verilog language server
---- Operation & Cloud Nativautoindente
"bashls", -- bash
"cmake", -- cmake language server
"clangd", -- c/c++
"dockerls", -- dockerfile
"jsonnet_ls", -- jsonnet language server
"terraformls", -- terraform hcl
"nushell", -- nushell language server
"scheme_langserver", -- scheme language server
},
formatting = {
disabled = {},
format_on_save = {
enabled = true,
allow_filetypes = {
"go",
"jsonnet",
"rust",
"terraform",
"nu",
},
},
},
},
}
@@ -0,0 +1,66 @@
-- Mapping data with "desc" stored directly by vim.keymap.set().
--
-- Please use this mappings table to set keyboard mapping since this is the
-- lower level configuration and more robust one. (which-key will
-- automatically pick-up stored data by this setting.)
local utils = require "astronvim.utils"
require("telescope").load_extension("refactoring")
require("telescope").load_extension("yank_history")
require("telescope").load_extension("undo")
return {
-- normal mode
n = {
-- second key is the lefthand side of the map
-- mappings seen under group name "Buffer"
["<leader>bn"] = { "<cmd>tabnew<cr>", desc = "New tab" },
-- quick save
["<C-s>"] = { ":w!<cr>", desc = "Save File" }, -- change description but the same command
-- Terminal
-- NOTE: https://neovim.io/doc/user/builtin.html#jobstart()
-- 1. If {cmd} is a List it runs directly (no 'shell')
-- 2. If {cmd} is a String it runs in the 'shell'
-- search and replace globally
['<leader>ss'] = {'<cmd>lua require("spectre").toggle()<CR>', desc = "Toggle Spectre" },
['<leader>sw'] = {'<cmd>lua require("spectre").open_visual({select_word=true})<CR>', desc = "Search current word" },
['<leader>sp'] ={'<cmd>lua require("spectre").open_file_search({select_word=true})<CR>', desc = "Search on current file" },
-- refactoring
["<leader>ri"] = { function() require('refactoring').refactor('Inline Variable') end, desc = "Inverse of extract variable" },
["<leader>rb"] = { function() require('refactoring').refactor('Extract Block') end, desc = "Extract Block" },
["<leader>rbf"] = { function() require('refactoring').refactor('Extract Block To File') end, desc = "Extract Block To File" },
["<leader>rr"] = { function() require('telescope').extensions.refactoring.refactors() end, desc = "Prompt for a refactor to apply" },
["<leader>rp"] = { function() require('refactoring').debug.printf({below = false}) end, desc = "Insert print statement to mark the calling of a function" },
["<leader>rv"] = { function() require('refactoring').debug.print_var() end, desc = "Insert print statement to print a variable" },
["<leader>rc"] = { function() require('refactoring').debug.cleanup({}) end, desc = "Cleanup of all generated print statements" },
-- yank_history
["<leader>yh"] = { function() require("telescope").extensions.yank_history.yank_history() end, desc = "Preview Yank History" },
-- undo history
["<leader>uh"] = {"<cmd>Telescope undo<cr>", desc="Telescope undo" },
-- implementation/definition preview
["gpd"] = { "<cmd>lua require('goto-preview').goto_preview_definition()<CR>", desc="goto_preview_definition" },
["gpt"] = { "<cmd>lua require('goto-preview').goto_preview_type_definition()<CR>", desc="goto_preview_type_definition" },
["gpi"] = { "<cmd>lua require('goto-preview').goto_preview_implementation()<CR>", desc="goto_preview_implementation" },
["gP" ] = { "<cmd>lua require('goto-preview').close_all_win()<CR>", desc="close_all_win" },
["gpr"] = { "<cmd>lua require('goto-preview').goto_preview_references()<CR>", desc="goto_preview_references" },
},
-- Visual mode
v = {
-- search and replace globally
['<leader>sw'] = {'<esc><cmd>lua require("spectre").open_visual()<CR>', desc = "Search current word" },
},
-- visual mode(what's the difference between v and x???)
x = {
-- refactoring
["<leader>ri"] = { function() require('refactoring').refactor('Inline Variable') end, desc = "Inverse of extract variable" },
["<leader>re"] = { function() require('refactoring').refactor('Extract Function') end, desc = "Extracts the selected code to a separate function" },
["<leader>rf"] = { function() require('refactoring').refactor('Extract Function To File') end, desc = "Extract Function To File" },
["<leader>rv"] = { function() require('refactoring').refactor('Extract Variable') end, desc = "Extracts occurrences of a selected expression to its own variable" },
["<leader>rr"] = { function() require('telescope').extensions.refactoring.refactors() end, desc = "Prompt for a refactor to apply" },
},
}
+56
View File
@@ -0,0 +1,56 @@
{
pkgs,
astronvim,
...
}:
###############################################################################
#
# AstroNvim's configuration and all its dependencies(lsp, formatter, etc.)
#
#e#############################################################################
let
shellAliases = {
v = "nvim";
vdiff = "nvim -d";
};
in {
xdg.configFile = {
# astronvim's config
"nvim" = {
source = astronvim;
force = true;
};
# my custom astronvim config, astronvim will load it after base config
# https://github.com/AstroNvim/AstroNvim/blob/v3.32.0/lua/astronvim/bootstrap.lua#L15-L16
"astronvim/lua/user" = {
source = ./astronvim_user;
force = true;
};
};
home.shellAliases = shellAliases;
programs.nushell.shellAliases = shellAliases;
programs = {
neovim = {
enable = true;
defaultEditor = true;
viAlias = true;
vimAlias = true;
# currently we use lazy.nvim as neovim's package manager, so comment this one.
# Install packages that will compile locally or download FHS binaries via Nix!
# and use lazy.nvim's `dir` option to specify the package directory in nix store.
# so that these plugins can work on NixOS.
#
# related project:
# https://github.com/b-src/lazy-nix-helper.nvim
plugins = with pkgs.vimPlugins; [
# search all the plugins using https://search.nixos.org/packages
telescope-fzf-native-nvim
];
};
};
}
+133
View File
@@ -0,0 +1,133 @@
{pkgs, ...}: {
nixpkgs.config = {
programs.npm.npmrc = ''
prefix = ''${HOME}/.npm-global
'';
};
home.packages = with pkgs; [
#-- c/c++
cmake
cmake-language-server
gnumake
checkmake
# c/c++ compiler, required by nvim-treesitter!
gcc
# c/c++ tools with clang-tools, the unwrapped version won't
# add alias like `cc` and `c++`, so that it won't conflict with gcc
llvmPackages.clang-unwrapped
lldb
#-- python
nodePackages.pyright # python language server
(python311.withPackages (
ps:
with ps; [
ruff-lsp
black # python formatter
jupyter
ipython
pandas
requests
pyquery
pyyaml
## emacs's lsp-bridge dependenciesge
epc
orjson
sexpdata
six
setuptools
paramiko
rapidfuzz
]
))
#-- rust
rust-analyzer
cargo # rust package manager
rustfmt
#-- nix
nil
rnix-lsp
# nixd
statix # Lints and suggestions for the nix programming language
deadnix # Find and remove unused code in .nix source files
alejandra # Nix Code Formatter
#-- golang
go
gomodifytags
iferr # generate error handling code for go
impl # generate function implementation for go
gotools # contains tools like: godoc, goimports, etc.
gopls # go language server
delve # go debugger
# -- java
jdk17
gradle
maven
spring-boot-cli
#-- lua
stylua
lua-language-server
#-- bash
nodePackages.bash-language-server
shellcheck
shfmt
#-- javascript/typescript --#
nodePackages.nodejs
nodePackages.typescript
nodePackages.typescript-language-server
# HTML/CSS/JSON/ESLint language servers extracted from vscode
nodePackages.vscode-langservers-extracted
nodePackages."@tailwindcss/language-server"
emmet-ls
# -- Lisp like Languages
guile
racket-minimal
fnlfmt # fennel
#-- Others
taplo # TOML language server / formatter / validator
nodePackages.yaml-language-server
sqlfluff # SQL linter
actionlint # GitHub Actions linter
buf # protoc plugin for linting and formatting
proselint # English prose linter
#-- Misc
tree-sitter # common language parser/highlighter
nodePackages.prettier # common code formatter
marksman # language server for markdown
glow # markdown previewer
fzf
pandoc # document converter
hugo # static site generator
#-- Optional Requirements:
gdu # disk usage analyzer, required by AstroNvim
(ripgrep.override {withPCRE2 = true;}) # recursively searches directories for a regex pattern
#-- CloudNative
nodePackages.dockerfile-language-server-nodejs
# terraform # install via brew on macOS
terraform-ls
jsonnet
jsonnet-language-server
hadolint # Dockerfile linter
#-- zig
zls
#-- verilog / systemverilog
verible
gdb
];
}