├── .stylua.toml
├── lua
    └── user
    │   ├── neo-tree.lua
    │   ├── impatient.lua
    │   ├── colorscheme.lua
    │   ├── notify.lua
    │   ├── lsp
    │       ├── settings
    │       │   ├── pyright.lua
    │       │   ├── sumneko_lua.lua
    │       │   └── jsonls.lua
    │       ├── init.lua
    │       ├── null-ls.lua
    │       ├── mason.lua
    │       └── lsp-installer.lua
    │   ├── shade.lua
    │   ├── commands.lua
    │   ├── typescript.lua
    │   ├── copilot.lua
    │   ├── indentline.lua
    │   ├── codeium.lua
    │   ├── miniIntentscope.lua
    │   ├── nvim-ts-autotag.lua
    │   ├── modicator.lua
    │   ├── colorizer.lua
    │   ├── import-cost.lua
    │   ├── conform.lua
    │   ├── autopairs.lua
    │   ├── winbar.lua
    │   ├── illuminate.lua
    │   ├── tabout.lua
    │   ├── comment.lua
    │   ├── toggleterm.lua
    │   ├── dap.lua
    │   ├── project.lua
    │   ├── autocommands.lua
    │   ├── navic.lua
    │   ├── code-action.lua
    │   ├── research.lua
    │   ├── trouble.lua
    │   ├── treesitter.lua
    │   ├── luasnip_setup.lua
    │   ├── todo-comments.lua
    │   ├── options.lua
    │   ├── gitsigns.lua
    │   ├── noice.lua
    │   ├── keymaps.lua
    │   └── telescope-cfg.lua
├── my-snippets
    └── typescript.lua
├── cool_snippets
    ├── all.json
    ├── crystal.json
    ├── cuda.json
    ├── elm.json
    ├── help.json
    ├── ledger.json
    ├── octave.json
    ├── pandoc.json
    ├── proto.json
    ├── rnoweb.json
    ├── svelte.json
    ├── vue.json
    ├── xhtml.json
    ├── htmljinja.json
    ├── lhaskell.json
    ├── php-laravel.json
    ├── bindzone.json
    ├── snippets.json
    ├── zsh.json
    ├── xml.json
    ├── matlab.json
    ├── supercollider.json
    ├── haskell.json
    ├── rust.json
    ├── javascript.json
    ├── rst.json
    ├── typescript_react.json
    ├── ejs.json
    ├── vim.json
    ├── erlang.json
    ├── typescript.json
    ├── javascript-angular.json
    ├── html_minimal.json
    ├── sh.json
    ├── json.json
    ├── smarty.json
    ├── go.json
    ├── eelixir.json
    ├── javascript-jasmine-arrow.json
    ├── javascript_react.json
    ├── julia.json
    ├── tcl.json
    ├── javascript-jsdoc.json
    ├── texmath.json
    ├── soy.json
    ├── bib.json
    ├── javascript-node.json
    ├── c.json
    ├── coffee.json
    ├── eruby.json
    ├── ruby.json
    ├── mako.json
    ├── markdown.json
    ├── php.json
    ├── lua.json
    ├── gitcommit.json
    ├── php-symfony2.json
    ├── coffee-react.json
    ├── javascript-ember.json
    ├── cpp.json
    ├── objc.json
    ├── perl.json
    ├── blade.json
    ├── jinja2.json
    ├── java.json
    ├── r.json
    ├── ocaml.json
    ├── coffee-jasmine.json
    └── puppet.json
├── .luarc.json
├── .gitignore
├── Dockerfile
├── Session.vim
├── init.lua
├── ftplugin
    └── java.lua
└── README.md


/.stylua.toml:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/lua/user/neo-tree.lua:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/my-snippets/typescript.lua:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/cool_snippets/all.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/crystal.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/cuda.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/elm.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/help.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/ledger.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/octave.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/pandoc.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/proto.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/rnoweb.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/svelte.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/vue.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/xhtml.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/htmljinja.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/lhaskell.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/cool_snippets/php-laravel.json:
--------------------------------------------------------------------------------
1 | {}
2 | 


--------------------------------------------------------------------------------
/.luarc.json:
--------------------------------------------------------------------------------
1 | {
2 |     "diagnostics.disable": [
3 |         "undefined-global"
4 |     ]
5 | }


--------------------------------------------------------------------------------
/lua/user/impatient.lua:
--------------------------------------------------------------------------------
1 | local status_ok, impatient = pcall(require, "impatient")
2 | if not status_ok then
3 |   return
4 | end
5 | 
6 | impatient.enable_profile()
7 | 


--------------------------------------------------------------------------------
/cool_snippets/bindzone.json:
--------------------------------------------------------------------------------
1 | {
2 |   "A": {
3 |     "prefix": "A",
4 |     "description": "Insert A Record",
5 |     "body": "${1:hostname}\tIN\t\tA\t${2:ip}"
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------
/lua/user/colorscheme.lua:
--------------------------------------------------------------------------------
1 | local colorscheme = "darkplus"
2 | local status_ok, _ = pcall(vim.cmd, "colorscheme " .. colorscheme)
3 | if not status_ok then
4 |   return
5 | end
6 | 


--------------------------------------------------------------------------------
/cool_snippets/snippets.json:
--------------------------------------------------------------------------------
1 | {
2 |   "vis": {
3 |     "prefix": "vis",
4 |     "description": "${VISUAL}",
5 |     "body": "\\${VISUAL${1:${2:default}${3:/transform/}}\\}"
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------
/lua/user/notify.lua:
--------------------------------------------------------------------------------
 1 | local present, notify = pcall(require, "notify")
 2 | 
 3 | if not present then
 4 | 	return
 5 | end
 6 | 
 7 | local options = {}
 8 | 
 9 | notify.setup(options)
10 | 


--------------------------------------------------------------------------------
/lua/user/lsp/settings/pyright.lua:
--------------------------------------------------------------------------------
 1 | return {
 2 |   settings = {
 3 |     python = {
 4 |       analysis = {
 5 |         typeCheckingMode = "off",
 6 |       },
 7 |     },
 8 |   },
 9 | }
10 | 


--------------------------------------------------------------------------------
/lua/user/lsp/init.lua:
--------------------------------------------------------------------------------
1 | local status_ok, _ = pcall(require, "lspconfig")
2 | if not status_ok then
3 | 	return
4 | end
5 | 
6 | require("user.lsp.mason")
7 | require("user.lsp.handlers").setup()
8 | require("user.lsp.null-ls")
9 | 


--------------------------------------------------------------------------------
/lua/user/shade.lua:
--------------------------------------------------------------------------------
 1 | local present, shade = pcall(require, "shade")
 2 | 
 3 | if not present then
 4 |   return
 5 | end
 6 | 
 7 | shade.setup {
 8 |   overlay_opacity = 35,
 9 |   opacity_step = 1,
10 |   exclude_filetypes = { "NvimTree" },
11 | }
12 | 


--------------------------------------------------------------------------------
/cool_snippets/zsh.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "#!": {
 3 |     "prefix": "#!",
 4 |     "description": "#!/usr/bin/env zsh",
 5 |     "body": [
 6 |       "#!/usr/bin/env zsh",
 7 |       "$0"
 8 |     ],
 9 |     "luasnip": {
10 |       "priority": -49
11 |     }
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/cool_snippets/xml.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "xml": {
 3 |     "prefix": "xml",
 4 |     "description": "XML declaration",
 5 |     "body": [
 6 |       "<?xml version=\"1.0\"?>",
 7 |       ""
 8 |     ],
 9 |     "luasnip": {
10 |       "priority": -50
11 |     }
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/lua/user/commands.lua:
--------------------------------------------------------------------------------
 1 | local create_cmd = vim.api.nvim_create_user_command
 2 | 
 3 | create_cmd("EnableShade", function()
 4 |   require("shade").setup()
 5 | end, {})
 6 | 
 7 | create_cmd("SearchIssue", function()
 8 |   require("user.research").MenuBrowser()
 9 | end, {})
10 | 


--------------------------------------------------------------------------------
/lua/user/typescript.lua:
--------------------------------------------------------------------------------
1 | require("typescript").setup({
2 |     disable_commands = false, -- prevent the plugin from creating Vim commands
3 |     debug = false, -- enable debug logging for commands
4 |     go_to_source_definition = {
5 |         fallback = true, -- fall back to standard LSP definition on failure
6 |     },
7 | })
8 | 


--------------------------------------------------------------------------------
/lua/user/copilot.lua:
--------------------------------------------------------------------------------
1 | -- local keymap = vim.keymap.set
2 | vim.cmd[[imap <silent><script><expr> <M-i> copilot#Accept()]]
3 | 
4 | -- keymap("i", "<M-i>", ":copilot#Accept('\\<CR>')<CR>", { silent = true })
5 | -- keymap("i", "<M-i>", function()
6 | -- 	return vim.fn["copilot#Accept()"]()
7 | -- end, { silent = true })
8 | vim.g.copilot_no_tab_map = true
9 | 


--------------------------------------------------------------------------------
/cool_snippets/matlab.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "switch": {
 3 |     "prefix": "switch",
 4 |     "description": "switch ... otherwise",
 5 |     "body": [
 6 |       "switch ${1:n}",
 7 |       "\tcase ${2:0}",
 8 |       "\t\t$3${4:",
 9 |       "\totherwise",
10 |       "\t\t$5}",
11 |       "end"
12 |     ],
13 |     "luasnip": {
14 |       "priority": -50
15 |     }
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/cool_snippets/supercollider.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "for": {
 3 |     "prefix": "for",
 4 |     "body": [
 5 |       "for (${1:1}, ${2:10}) {${3: |i}|\\}",
 6 |       "\t$0",
 7 |       "\\}"
 8 |     ]
 9 |   },
10 |   "sdef": {
11 |     "prefix": "sdef",
12 |     "body": [
13 |       "SynthDef(\\${1:synthName}, {${2: |${3:x}|}",
14 |       "\t$0",
15 |       "\\}).add;"
16 |     ]
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/cool_snippets/haskell.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "imp": {
 3 |     "prefix": "imp",
 4 |     "description": "Simple import",
 5 |     "body": "import ${1:${2:Data}.${0:Text}}",
 6 |     "luasnip": {
 7 |       "priority": -50
 8 |     }
 9 |   },
10 |   "imp2": {
11 |     "prefix": "imp2",
12 |     "description": "Selective import",
13 |     "body": "import ${1:${2:Data}.${3:Text}} ($4)$0"
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/cool_snippets/rust.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   ".it": {
 3 |     "prefix": ".it",
 4 |     "description": ".iter()",
 5 |     "body": ".iter()$0"
 6 |   },
 7 |   "impl": {
 8 |     "prefix": "impl",
 9 |     "description": "Struct/Trait implementation",
10 |     "body": [
11 |       "impl$4 ${1:Type/Trait}${2: for ${3:Type}}${4:<${5:T}>} {",
12 |       "\t$0",
13 |       "\\}"
14 |     ]
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/cool_snippets/javascript.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   ":,": {
 3 |     "prefix": ":,",
 4 |     "description": "Object Value JS",
 5 |     "body": "${1:value_name}: ${0:value},"
 6 |   },
 7 |   ":": {
 8 |     "prefix": ":",
 9 |     "description": "Object key key: 'value'",
10 |     "body": "${1:key}: ${2:\"${3:value}\"}${4:, }"
11 |   },
12 |   "imp": {
13 |     "prefix": "imp",
14 |     "description": "import",
15 |     "body": "import $2 from $1"
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/lua/user/lsp/settings/sumneko_lua.lua:
--------------------------------------------------------------------------------
 1 | return {
 2 |   settings = {
 3 |     Lua = {
 4 |       diagnostics = {
 5 |         globals = { "vim", 'use', 'bit' },
 6 |       },
 7 |       workspace = {
 8 |         library = {
 9 |           [vim.fn.expand "$VIMRUNTIME/lua"] = true,
10 |           [vim.fn.stdpath "config" .. "/lua"] = true,
11 |         },
12 |       },
13 |       telemetry = {
14 |         enable = false,
15 |       },
16 |     },
17 |   },
18 | }
19 | 


--------------------------------------------------------------------------------
/cool_snippets/rst.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "fnt": {
 3 |     "prefix": "fnt",
 4 |     "description": "Footnote or Citation",
 5 |     "body": [
 6 |       "[${1:Label}]_ $0",
 7 |       "",
 8 |       ".. [$1] ${2:Reference}"
 9 |     ]
10 |   },
11 |   "sid": {
12 |     "prefix": "sid",
13 |     "description": "SideBar",
14 |     "body": [
15 |       ".. sidebar:: ${1:SideBar Title}",
16 |       "",
17 |       "\t${2:${TM_SELECTED_TEXT:SideBar Content}}"
18 |     ]
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/lua/user/indentline.lua:
--------------------------------------------------------------------------------
 1 | local status_ok, indent_blankline = pcall(require, "ibl")
 2 | if not status_ok then
 3 |   return
 4 | end
 5 | 
 6 | indent_blankline.setup {
 7 |   char = "▏",
 8 |   show_trailing_blankline_indent = false,
 9 |   show_first_indent_level = true,
10 |   use_treesitter = true,
11 |   show_current_context = true,
12 |   buftype_exclude = { "terminal", "nofile" },
13 |   filetype_exclude = {
14 |     "help",
15 |     "packer",
16 |     "NvimTree",
17 |   },
18 | }
19 | 


--------------------------------------------------------------------------------
/lua/user/codeium.lua:
--------------------------------------------------------------------------------
 1 | --
 2 | 
 3 | if vim.fn.has "mac" == 1 then
 4 | vim.cmd[[imap <silent><script><expr> <C-i> codeium#Accept()]]
 5 | else
 6 | 
 7 | vim.cmd[[imap <silent><script><expr> <M-i> codeium#Accept()]]
 8 | end
 9 | 
10 | -- vim.api.nvim_set_keymap('n', '<D-i>', ':call codeium#Accept()<CR>', { noremap = true, silent = true })
11 | -- -- vim.api.nvim_set_keymap('i', '<D-i>', '<C-o>:call codeium#Accept()<CR>', { noremap = true, silent = true })
12 | vim.g.codeium_no_map_tab = true
13 | 


--------------------------------------------------------------------------------
/cool_snippets/typescript_react.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "rfc": {
 3 |     "prefix": "rfc",
 4 |     "description": "react functional component",
 5 |     "body": [
 6 |       "import React, { FC \\} from \"react\"",
 7 |       "",
 8 |       "interface ${1:function_name}Props {${4:props_types}\\}",
 9 |       "",
10 |       "export const ${1:function_name}: FC<${1:function_name}Props> = (${2:props}) => ${3:function_body}"
11 |     ],
12 |     "luasnip": {
13 |       "priority": -49
14 |     }
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/cool_snippets/ejs.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "for": {
 3 |     "prefix": "for",
 4 |     "description": "ejs for loop",
 5 |     "body": [
 6 |       "<% for (let ${1:i = 0}; ${2:i<arr.length}; ${3:i++}) { %>",
 7 |       "\t${0:body}",
 8 |       "<% \\} %>"
 9 |     ]
10 |   },
11 |   "forE": {
12 |     "prefix": "forE",
13 |     "description": "ejs for Each loop",
14 |     "body": [
15 |       "<% ${1:array}.forEach((${2:single var}) => { %>",
16 |       "\t${0:body}",
17 |       "<% \\}) %>"
18 |     ]
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/cool_snippets/vim.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "gvar": {
 3 |     "prefix": "gvar",
 4 |     "description": "Global / configuration variable",
 5 |     "body": [
 6 |       "if !exists(\"g:${1:MyUltraImportantVar}\")",
 7 |       "\tlet g:$1 = ${2:\"${3:<tab>}\"}",
 8 |       "endif"
 9 |     ],
10 |     "luasnip": {
11 |       "priority": -50
12 |     }
13 |   },
14 |   "f": {
15 |     "prefix": "f",
16 |     "description": "function",
17 |     "body": [
18 |       "fun ${1:function_name}($2)",
19 |       "\t${3:\" code}",
20 |       "endf"
21 |     ]
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/lua/user/miniIntentscope.lua:
--------------------------------------------------------------------------------
 1 | local status_ok, indent_blankline = pcall(require, "mini.indentscope")
 2 | if not status_ok then
 3 |   return
 4 | end
 5 | 
 6 | indent_blankline.setup {
 7 |   symbol = "|",
 8 |   show_trailing_blankline_indent = false,
 9 |   show_first_indent_level = true,
10 |   options = { try_as_border = true },
11 |   use_treesitter = true,
12 |   show_current_context = true,
13 |   buftype_exclude = { "terminal", "nofile" },
14 |   filetype_exclude = {
15 |     "help",
16 |     "packer",
17 |     "NvimTree",
18 |   },
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/lua/user/nvim-ts-autotag.lua:
--------------------------------------------------------------------------------
 1 | require("nvim-ts-autotag").setup({
 2 | 	opts = {
 3 | 		-- Defaults
 4 | 		enable_close = true, -- Auto close tags
 5 | 		enable_rename = true, -- Auto rename pairs of tags
 6 | 		enable_close_on_slash = false, -- Auto close on trailing </
 7 | 	},
 8 | 	-- Also override individual filetype configs, these take priority.
 9 | 	-- Empty by default, useful if one of the "opts" global settings
10 | 	-- doesn't work well in a specific filetype
11 | 	-- per_filetype = {
12 | 	--   ["html"] = {
13 | 	--     enable_close = false
14 | 	--   }
15 | 	-- }
16 | })
17 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Lua sources
 2 | luac.out
 3 | 
 4 | # luarocks build files
 5 | *.src.rock
 6 | *.zip
 7 | *.tar.gz
 8 | 
 9 | # Object files
10 | *.o
11 | *.os
12 | *.ko
13 | *.obj
14 | *.elf
15 | 
16 | # Precompiled Headers
17 | *.gch
18 | *.pch
19 | 
20 | # Libraries
21 | *.lib
22 | *.a
23 | *.la
24 | *.lo
25 | *.def
26 | *.exp
27 | 
28 | # Shared objects (inc. Windows DLLs)
29 | *.dll
30 | *.so
31 | *.so.*
32 | *.dylib
33 | 
34 | # Executables
35 | *.exe
36 | *.out
37 | *.app
38 | *.i*86
39 | *.x86_64
40 | *.hex
41 | 
42 | 
43 | plugin/packer_compiled.lua
44 | java-debug/
45 | vscode-java-test/
46 | 


--------------------------------------------------------------------------------
/cool_snippets/erlang.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "pat": {
 3 |     "prefix": "pat",
 4 |     "description": "Case:Receive:Try Clause",
 5 |     "body": [
 6 |       "${1:pattern}${2: when ${3:guard}} ->",
 7 |       "\t${4:body}"
 8 |     ],
 9 |     "luasnip": {
10 |       "priority": -50
11 |     }
12 |   },
13 |   "||": {
14 |     "prefix": "||",
15 |     "description": "List Comprehension",
16 |     "body": "[${1:X} || ${2:X} <- ${3:List}${4:, gen}]"
17 |   },
18 |   "gen": {
19 |     "prefix": "gen",
20 |     "description": "Generator Expression",
21 |     "body": "${1:X} <- ${2:List}${3:, gen}"
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/lua/user/modicator.lua:
--------------------------------------------------------------------------------
 1 | local present, modicator = pcall(require, "modicator")
 2 | 
 3 | if not present then
 4 | 	return
 5 | end
 6 | 
 7 | modicator.setup({
 8 | 	line_numbers = true,
 9 | 	cursorline = true,
10 | 	highlights = {
11 | 		modes = {
12 | 			["i"] = modicator.get_highlight_fg("Question"),
13 | 			["v"] = modicator.get_highlight_fg("Type"),
14 | 			["V"] = modicator.get_highlight_fg("Type"),
15 | 			["�"] = modicator.get_highlight_fg("Type"),
16 | 			["s"] = modicator.get_highlight_fg("Keyword"),
17 | 			["S"] = modicator.get_highlight_fg("Keyword"),
18 | 			["R"] = modicator.get_highlight_fg("Title"),
19 | 			["c"] = modicator.get_highlight_fg("Constant"),
20 | 		},
21 | 	},
22 | })
23 | 


--------------------------------------------------------------------------------
/lua/user/colorizer.lua:
--------------------------------------------------------------------------------
 1 | local status_ok, colorizer = pcall(require, "colorizer")
 2 | if not status_ok then
 3 |   return
 4 | end
 5 | 
 6 | colorizer.setup({ "*" }, {
 7 |   RGB = true, -- #RGB hex codes
 8 |   RRGGBB = true, -- #RRGGBB hex codes
 9 |   names = false, -- "Name" codes like Blue oe blue
10 |   RRGGBBAA = true, -- #RRGGBBAA hex codes
11 |   rgb_fn = true, -- CSS rgb() and rgba() functions
12 |   hsl_fn = true, -- CSS hsl() and hsla() functions
13 |   css = false, -- Enable all CSS features: rgb_fn, hsl_fn, names, RGB, RRGGBB
14 |   css_fn = false, -- Enable all CSS *functions*: rgb_fn, hsl_fn
15 |   -- Available modes: foreground, background, virtualtext
16 |   mode = "background", -- Set the display mode.)
17 | })
18 | 


--------------------------------------------------------------------------------
/cool_snippets/typescript.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "int": {
 3 |     "prefix": "int",
 4 |     "description": "interface",
 5 |     "body": [
 6 |       "interface $1 {",
 7 |       "\\}"
 8 |     ],
 9 |     "luasnip": {
10 |       "priority": -50
11 |     }
12 |   },
13 |   "nspc": {
14 |     "prefix": "nspc",
15 |     "description": "namespace",
16 |     "body": [
17 |       "namespace $1 {",
18 |       "\\}"
19 |     ]
20 |   },
21 |   "fun": {
22 |     "prefix": "fun",
23 |     "description": "function (named)",
24 |     "body": [
25 |       "function ${1:function_name} (${2:argument}: ${3:argument_type}) {",
26 |       "\t$TM_SELECTED_TEXT$0",
27 |       "\\}"
28 |     ],
29 |     "luasnip": {
30 |       "priority": -49
31 |     }
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/cool_snippets/javascript-angular.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "iti": {
 3 |     "prefix": "iti",
 4 |     "description": "it (js, inject)",
 5 |     "body": [
 6 |       "it('${1:description}', inject(function($2) {",
 7 |       "\t$0",
 8 |       "\\}));"
 9 |     ],
10 |     "luasnip": {
11 |       "priority": -50
12 |     }
13 |   },
14 |   "befi": {
15 |     "prefix": "befi",
16 |     "description": "before each (js, inject)",
17 |     "body": [
18 |       "beforeEach(inject(function($1) {",
19 |       "\t$0",
20 |       "\\}));"
21 |     ]
22 |   },
23 |   "aconf": {
24 |     "prefix": "aconf",
25 |     "description": "angular config",
26 |     "body": [
27 |       "config(function($1) {",
28 |       "\t$0",
29 |       "\\});"
30 |     ]
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/lua/user/import-cost.lua:
--------------------------------------------------------------------------------
 1 | require('import-cost').setup({
 2 |         -- Filetypes to attach to
 3 |         filetypes = {
 4 |             'javascript',
 5 |             'javascriptreact',
 6 |             'typescript',
 7 |             'typescriptreact',
 8 |         },
 9 |         format = {
10 |             -- Format string for bytes/kilobytes in virtual text
11 |             byte_format = '%.1fb',
12 |             kb_format = '%.1fk',
13 |             -- Virtual text format (remove second "%s" to ignore gzipped size)
14 |             virtual_text = '%s (gzipped: %s)',
15 |         },
16 |         -- Highlight of virtual text —
17 |         -- a highlight group to link to or table as specified by nvim_set_hl()
18 |         highlight = 'Comment',
19 |     })
20 | 


--------------------------------------------------------------------------------
/lua/user/conform.lua:
--------------------------------------------------------------------------------
 1 | require("conform").setup({
 2 |   formatters_by_ft = {
 3 |     lua = { "stylua" },
 4 |     javascript = { "prettierd", "prettier" },
 5 |     typescript = { "prettierd", "prettier" },
 6 |     css = { "prettierd", "prettier" },
 7 |     scss = { "prettierd", "prettier" },
 8 |     markdown = { "prettierd", "prettier" },
 9 |     html = { "prettierd", "prettier" },
10 |     json = { "prettierd", "prettier" },
11 |     yaml = { "prettierd", "prettier" },
12 |     graphql = { "prettierd", "prettier" },
13 |     md = { "prettierd", "prettier" },
14 |     txt = { "prettierd", "prettier" },
15 |     sh = { "beautysh" },
16 |   },
17 |   formatters = {
18 |     stylua = {
19 |       args = { "--indent-width", "4", "--indent-type", "Spaces", "-" },
20 |     },
21 |   },
22 |   -- Set up format-on-save
23 |   -- format_on_save = { timeout_ms = 500, lsp_fallback = true },
24 | })
25 | 


--------------------------------------------------------------------------------
/cool_snippets/html_minimal.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "id": {
 3 |     "prefix": "id",
 4 |     "body": "id=\"$1\"$2",
 5 |     "luasnip": {
 6 |       "priority": -49
 7 |     }
 8 |   },
 9 |   "idn": {
10 |     "prefix": "idn",
11 |     "body": "id=\"$1\" name=\"${2:$1}\""
12 |   },
13 |   "label_and_input": {
14 |     "prefix": "label_and_input",
15 |     "body": [
16 |       "<label for=\"${2:$1}\">$1</label>",
17 |       "<input type=\"${3:text}\" name=\"${4:$2}\"${5: id=\"${6:$2}\"} value=\"$7\" />$8"
18 |     ]
19 |   },
20 |   "input": {
21 |     "prefix": "input",
22 |     "body": "<input type=\"${1:text}\" value=\"$2\" name=\"$3\"${4: id=\"${5:$3}\"}/>$7"
23 |   },
24 |   "submit": {
25 |     "prefix": "submit",
26 |     "body": "<input type=\"submit\" value=\"$2\" $3/>$7"
27 |   },
28 |   "textarea": {
29 |     "prefix": "textarea",
30 |     "body": "<textarea name=\"$2\"${3: id=\"$4\"}>$5</textarea>"
31 |   },
32 |   "img": {
33 |     "prefix": "img",
34 |     "body": "<img src=\"$1\"${2: alt=\"$3\"}/>"
35 |   }
36 | }
37 | 


--------------------------------------------------------------------------------
/lua/user/autopairs.lua:
--------------------------------------------------------------------------------
 1 | -- Setup nvim-cmp.
 2 | local status_ok, npairs = pcall(require, "nvim-autopairs")
 3 | if not status_ok then
 4 | 	return
 5 | end
 6 | 
 7 | npairs.setup({
 8 | 	check_ts = true, -- treesitter integration
 9 | 	disable_filetype = { "TelescopePrompt" },
10 | 	ts_config = {
11 | 		lua = { "string", "source" },
12 | 		javascript = { "string", "template_string" },
13 | 		java = false,
14 | 	},
15 | 
16 | 	fast_wrap = {
17 | 		map = "<M-e>",
18 | 		chars = { "{", "[", "(", '"', "'" },
19 | 		pattern = string.gsub([[ [%'%"%)%>%]%)%}%,] ]], "%s+", ""),
20 | 		offset = 0, -- Offset from pattern match
21 | 		end_key = "$",
22 | 		keys = "qwertyuiopzxcvbnmasdfghjkl",
23 | 		check_comma = true,
24 | 		highlight = "PmenuSel",
25 | 		highlight_grey = "LineNr",
26 | 	},
27 | })
28 | 
29 | -- local cmp_autopairs = require("nvim-autopairs.completion.cmp")
30 | -- local cmp_status_ok, cmp = pcall(require, "cmp")
31 | -- if not cmp_status_ok then
32 | -- 	return
33 | -- end
34 | -- cmp.event:on("confirm_done", cmp_autopairs.on_confirm_done({}))
35 | 


--------------------------------------------------------------------------------
/lua/user/winbar.lua:
--------------------------------------------------------------------------------
 1 | local icons = require("user.icons")
 2 | 
 3 | if vim.version().major > 7 then
 4 |   require("winbar").setup {
 5 | 
 6 |     enabled = true,
 7 | 
 8 |     show_file_path = true,
 9 |     show_symbols = true,
10 | 
11 |     colors = {
12 |       path = "", -- You can customize colors like #c946fd
13 |       file_name = "",
14 |       symbols = "",
15 |     },
16 |     icons = {
17 |       -- file_icon_default = "",
18 |       -- seperator = ">",
19 |       -- editor_state = "●",
20 |       -- lock_icon = "",
21 | 
22 |       file_icon_default = icons.ui.File,
23 |       seperator = ">",
24 |       editor_state = icons.ui.Pencil,
25 |       lock_icon = icons.ui.Lock,
26 |     },
27 | 
28 |     exclude_filetype = {
29 |       "help",
30 |       "startify",
31 |       "dashboard",
32 |       "packer",
33 |       "neogitstatus",
34 |       "NvimTree",
35 |       "Trouble",
36 |       "alpha",
37 |       "lir",
38 |       "Outline",
39 |       "spectre_panel",
40 |       "toggleterm",
41 |       "qf",
42 |     },
43 |   }
44 | else
45 |   return {}
46 | end
47 | 


--------------------------------------------------------------------------------
/lua/user/illuminate.lua:
--------------------------------------------------------------------------------
 1 | local status_ok, illuminate = pcall(require, "illuminate")
 2 | if not status_ok then
 3 | 	return
 4 | end
 5 | 
 6 | vim.g.Illuminate_ftblacklist = {'alpha', 'NvimTree'}
 7 | vim.api.nvim_set_keymap('n', '<a-n>', '<cmd>lua require"illuminate".next_reference{wrap=true}<cr>', {noremap=true})
 8 | vim.api.nvim_set_keymap('n', '<a-p>', '<cmd>lua require"illuminate".next_reference{reverse=true,wrap=true}<cr>', {noremap=true})
 9 | 
10 | illuminate.configure {
11 |   providers = {
12 |     "lsp",
13 |     "treesitter",
14 |     "regex",
15 |   },
16 |   delay = 200,
17 |   filetypes_denylist = {
18 |     "dirvish",
19 |     "fugitive",
20 |     "alpha",
21 |     "NvimTree",
22 |     "packer",
23 |     "neogitstatus",
24 |     "Trouble",
25 |     "lir",
26 |     "Outline",
27 |     "spectre_panel",
28 |     "toggleterm",
29 |     "DressingSelect",
30 |     "TelescopePrompt",
31 |   },
32 |   filetypes_allowlist = {},
33 |   modes_denylist = {},
34 |   modes_allowlist = {},
35 |   providers_regex_syntax_denylist = {},
36 |   providers_regex_syntax_allowlist = {},
37 |   under_cursor = true,
38 | }
39 | 


--------------------------------------------------------------------------------
/cool_snippets/sh.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "elif": {
 3 |     "prefix": "elif",
 4 |     "description": "elif .. (elif)",
 5 |     "body": [
 6 |       "elif ${2:[[ ${1:condition} ]]}; then",
 7 |       "\t${0:$TM_SELECTED_TEXT}"
 8 |     ]
 9 |   },
10 |   "for": {
11 |     "prefix": "for",
12 |     "description": "for ... done (for)",
13 |     "body": [
14 |       "for (( i = 0; i < ${1:10}; i++ )); do",
15 |       "\t${0:$TM_SELECTED_TEXT}",
16 |       "done"
17 |     ]
18 |   },
19 |   "if": {
20 |     "prefix": "if",
21 |     "description": "if ... then (if)",
22 |     "body": [
23 |       "if [[ ${1:condition} ]]; then",
24 |       "\t${0:$TM_SELECTED_TEXT}",
25 |       "fi"
26 |     ]
27 |   },
28 |   "until": {
29 |     "prefix": "until",
30 |     "description": "until ... (done)",
31 |     "body": [
32 |       "until ${2:[[ ${1:condition} ]]}; do",
33 |       "\t${0:$TM_SELECTED_TEXT}",
34 |       "done"
35 |     ]
36 |   },
37 |   "func": {
38 |     "prefix": "func",
39 |     "description": "function() {...}",
40 |     "body": [
41 |       "${1:function} () {",
42 |       "\t${0:$TM_SELECTED_TEXT}",
43 |       "\\}"
44 |     ]
45 |   }
46 | }
47 | 


--------------------------------------------------------------------------------
/cool_snippets/json.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "s": {
 3 |     "prefix": "s",
 4 |     "description": "String",
 5 |     "body": "\"${1:key}\": \"${0:value}\",",
 6 |     "luasnip": {
 7 |       "priority": -50
 8 |     }
 9 |   },
10 |   "n": {
11 |     "prefix": "n",
12 |     "description": "Number",
13 |     "body": "\"${1:key}\": ${0:value},"
14 |   },
15 |   "a": {
16 |     "prefix": "a",
17 |     "description": "Array",
18 |     "body": [
19 |       "[",
20 |       "\t$TM_SELECTED_TEXT$0",
21 |       "],"
22 |     ]
23 |   },
24 |   "na": {
25 |     "prefix": "na",
26 |     "description": "Named array",
27 |     "body": [
28 |       "\"${1:key}\": [",
29 |       "\t$TM_SELECTED_TEXT$0",
30 |       "],"
31 |     ]
32 |   },
33 |   "o": {
34 |     "prefix": "o",
35 |     "description": "Object",
36 |     "body": [
37 |       "{",
38 |       "\t$TM_SELECTED_TEXT$0",
39 |       "\\},"
40 |     ]
41 |   },
42 |   "no": {
43 |     "prefix": "no",
44 |     "description": "Named object",
45 |     "body": [
46 |       "\"${1:key}\": {",
47 |       "\t$TM_SELECTED_TEXT$0",
48 |       "\\},"
49 |     ]
50 |   },
51 |   "null": {
52 |     "prefix": "null",
53 |     "description": "Null",
54 |     "body": "\"${0:key}\": null,"
55 |   }
56 | }
57 | 


--------------------------------------------------------------------------------
/lua/user/tabout.lua:
--------------------------------------------------------------------------------
 1 | local tabout = require("tabout")
 2 | tabout.setup {
 3 |     tabkey = '<Tab>', -- key to trigger tabout, set to an empty string to disable
 4 |     backwards_tabkey = '<S-Tab>', -- key to trigger backwards tabout, set to an empty string to disable
 5 |     act_as_tab = true, -- shift content if tab out is not possible
 6 |     act_as_shift_tab = false, -- reverse shift content if tab out is not possible (if your keyboard/terminal supports <S-Tab>)
 7 |     default_tab = '<C-t>', -- shift default action (only at the beginning of a line, otherwise <TAB> is used)
 8 |     default_shift_tab = '<C-d>', -- reverse shift default action,
 9 |     enable_backwards = true, -- well ...
10 |     completion = true, -- if the tabkey is used in a completion pum
11 |     tabouts = {
12 |       {open = "'", close = "'"},
13 |       {open = '"', close = '"'},
14 |       {open = '`', close = '`'},
15 |       {open = '(', close = ')'},
16 |       {open = '[', close = ']'},
17 |       {open = '{', close = '}'}
18 |     },
19 |     ignore_beginning = true, --[[ if the cursor is at the beginning of a filled element it will rather tab out than shift the content ]]
20 |     exclude = {} -- tabout will ignore these filetypes
21 | }
22 | 


--------------------------------------------------------------------------------
/cool_snippets/smarty.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "append": {
 3 |     "prefix": "append",
 4 |     "description": "{append} is used for creating or appending template variable arrays during the execution of a template.",
 5 |     "body": "{append var='$1' value='$2'${3: index='${4|first,last|}'}${5: scope='${6|parent,root,global|}'}\\}"
 6 |   },
 7 |   "assign": {
 8 |     "prefix": "assign",
 9 |     "description": "{assign} is used for assigning template variables during the execution of a template.",
10 |     "body": "{assign var='$1' value='$2'${3: scope='${4|parent,root,global|}'}\\}"
11 |   },
12 |   "config_load": {
13 |     "prefix": "config_load",
14 |     "description": "config_load",
15 |     "body": "{config_load file='$1'${2: section='$3'}${4: scope='${5|local,parent,global|}'}\\}"
16 |   },
17 |   "include": {
18 |     "prefix": "include",
19 |     "description": "{include} tags are used for including other templates in the current template. Any variables available in the current template are also available within the included template.",
20 |     "body": "{include file='$1'${2: assign='$3'}${4: cache_lifetime=$5}${6: compile_id='$7'}${8: cache_id='$9'}${10: scope='${11|parent,root,global|}'}${12: variables}\\}"
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/lua/user/comment.lua:
--------------------------------------------------------------------------------
 1 | local status_ok, comment = pcall(require, "Comment")
 2 | if not status_ok then
 3 |   return
 4 | end
 5 | 
 6 | comment.setup({
 7 |   -- pre_hook = function(ctx)
 8 |   -- 	-- Only calculate commentstring for tsx filetypes
 9 |   -- 	if vim.bo.filetype == "typescriptreact" then
10 |   -- 		local U = require("Comment.utils")
11 |   --
12 |   -- 		-- Determine whether to use linewise or blockwise commentstring
13 |   -- 		local type = ctx.ctype == U.ctype.linewise and "__default" or "__multiline"
14 |   --
15 |   -- 		-- Determine the location where to calculate commentstring from
16 |   -- 		local location = nil
17 |   -- 		if ctx.ctype == U.ctype.blockwise then
18 |   -- 			location = require("ts_context_commentstring.utils").get_cursor_location()
19 |   -- 		elseif ctx.cmotion == U.cmotion.v or ctx.cmotion == U.cmotion.V then
20 |   -- 			location = require("ts_context_commentstring.utils").get_visual_start_location()
21 |   -- 		end
22 |   --
23 |   -- 		return require("ts_context_commentstring.internal").calculate_commentstring({
24 |   -- 			key = type,
25 |   -- 			location = location,
26 |   -- 		})
27 |   -- 	end
28 |   -- end,
29 |   pre_hook = require('ts_context_commentstring.integrations.comment_nvim').create_pre_hook(),
30 | })
31 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | From alpine:latest
 2 | 
 3 | # RUN apk add --update \
 4 | #   git \
 5 | #   nodejs \
 6 | #   npm \
 7 | #   curl \
 8 | #   make \
 9 | #   cmake \
10 | #   build-base\
11 | #   libtool \
12 | #   automake \
13 | #   && rm -rf /var/cache/apk/*
14 | 
15 | RUN apk add --update \
16 |   git \
17 |   alpine-sdk build-base\
18 |   libtool \
19 |   automake \
20 |   m4 \
21 |   autoconf \
22 |   linux-headers \
23 |   unzip \
24 |   ncurses ncurses-dev ncurses-libs ncurses-terminfo \
25 |   clang \
26 |   nodejs \
27 |   xz \
28 |   curl \
29 |   make \
30 |   cmake \
31 |   && rm -rf /var/cache/apk/*
32 | 
33 | # RUN curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim.appimage && \
34 | #   chmod u+x nvim.appimage && \
35 |   # ./nvim.appimage --appimage-extract && \
36 |   # ./squashfs-root/AppRun --version && \
37 |   # mv squashfs-root / && \
38 |   # ln -s /squashfs-root/AppRun /usr/bin/nvim
39 | 
40 | 
41 | RUN git clone https://github.com/neovim/neovim.git && \
42 |   cd neovim && \
43 |   make distclean && \
44 |   make && \
45 |   make install && \
46 |   cd ../ && rm -rf nvim
47 | 
48 | RUN git clone https://github.com/PiyushDuggal-source/neovim.git ~/.config/nvim && \
49 |   cd ~/.config/nvim && git fetch && git checkout stable && \
50 |   npm install -g neovim
51 | 


--------------------------------------------------------------------------------
/lua/user/toggleterm.lua:
--------------------------------------------------------------------------------
 1 | local status_ok, toggleterm = pcall(require, "toggleterm")
 2 | if not status_ok then
 3 |   return
 4 | end
 5 | 
 6 | toggleterm.setup({
 7 |   size = 30,
 8 |   open_mapping = [[<c-\>]],
 9 |   hide_numbers = true,
10 |   shade_terminals = true,
11 |   shading_factor = 2,
12 |   start_in_insert = true,
13 |   insert_mappings = true,
14 |   persist_size = true,
15 |   direction = "horizontal",
16 |   close_on_exit = true,
17 |   shell = vim.o.shell,
18 |   float_opts = {
19 |     border = "curved",
20 |   },
21 | })
22 | 
23 | function _G.set_terminal_keymaps()
24 |   local opts = {noremap = true}
25 |   -- vim.api.nvim_buf_set_keymap(0, 't', '<esc>', [[<C-\><C-n>]], opts)
26 |   vim.api.nvim_buf_set_keymap(0, 't', '<C-h>', [[<C-\><C-n><C-W>h]], opts)
27 |   vim.api.nvim_buf_set_keymap(0, 't', '<C-j>', [[<C-\><C-n><C-W>j]], opts)
28 |   vim.api.nvim_buf_set_keymap(0, 't', '<C-k>', [[<C-\><C-n><C-W>k]], opts)
29 |   vim.api.nvim_buf_set_keymap(0, 't', '<C-l>', [[<C-\><C-n><C-W>l]], opts)
30 | end
31 | 
32 | vim.cmd('autocmd! TermOpen term://* lua set_terminal_keymaps()')
33 | 
34 | local Terminal = require("toggleterm.terminal").Terminal
35 | 
36 | local lazygit = Terminal:new({ cmd = "lazygit", hidden = true, direction= "float"})
37 | 
38 | function _LAZYGIT_TOGGLE()
39 | 	lazygit:toggle()
40 | end
41 | 
42 | 


--------------------------------------------------------------------------------
/cool_snippets/go.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "struct": {
 3 |     "prefix": "struct",
 4 |     "description": "Struct declaration",
 5 |     "body": [
 6 |       "type ${1:Struct} struct {",
 7 |       "\t${0:$TM_SELECTED_TEXT}",
 8 |       "\\}"
 9 |     ]
10 |   },
11 |   "interface": {
12 |     "prefix": "interface",
13 |     "description": "Interface declaration",
14 |     "body": [
15 |       "type ${1:Interface} interface {",
16 |       "\t${0:$TM_SELECTED_TEXT}",
17 |       "\\}"
18 |     ]
19 |   },
20 |   "funch": {
21 |     "prefix": "funch",
22 |     "description": "HTTP handler",
23 |     "body": [
24 |       "func ${1:handler}(${2:w} http.ResponseWriter, ${3:r} *http.Request) {",
25 |       "\t${0:$TM_SELECTED_TEXT}",
26 |       "\\}"
27 |     ]
28 |   },
29 |   "map": {
30 |     "prefix": "map",
31 |     "description": "Map type",
32 |     "body": "map[${1:keytype}]${2:valtype}"
33 |   },
34 |   ":": {
35 |     "prefix": ":",
36 |     "description": "Variable declaration :=",
37 |     "body": "${1:name} := ${0:value}"
38 |   },
39 |   "json": {
40 |     "prefix": "json",
41 |     "description": "JSON field",
42 |     "body": "`json:\"${1:displayName}\"`"
43 |   },
44 |   "err": {
45 |     "prefix": "err",
46 |     "description": "Basic error handling",
47 |     "body": [
48 |       "if err != nil {",
49 |       "\tlog.${1:Fatal}(err)",
50 |       "\\}"
51 |     ]
52 |   }
53 | }
54 | 


--------------------------------------------------------------------------------
/cool_snippets/eelixir.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "%": {
 3 |     "prefix": "%",
 4 |     "description": "<% %>",
 5 |     "body": "<% $0 %>",
 6 |     "luasnip": {
 7 |       "priority": -50
 8 |     }
 9 |   },
10 |   "=": {
11 |     "prefix": "=",
12 |     "description": "<%= %>",
13 |     "body": "<%= $0 %>"
14 |   },
15 |   "end": {
16 |     "prefix": "end",
17 |     "description": "<% end %>",
18 |     "body": "<% end %>"
19 |   },
20 |   "for": {
21 |     "prefix": "for",
22 |     "body": [
23 |       "<%= for ${1:item} <- ${2:$1s} ${3:@conn} do %>",
24 |       "\t$0",
25 |       "<% end %>"
26 |     ]
27 |   },
28 |   "ft": {
29 |     "prefix": "ft",
30 |     "description": "form_tag",
31 |     "body": [
32 |       "<%= form_tag(${1:\"${2:/users}\"}, method: ${3::post}) %>",
33 |       "\t$0",
34 |       "</form>"
35 |     ]
36 |   },
37 |   "lin": {
38 |     "prefix": "lin",
39 |     "description": "link",
40 |     "body": "<%= link ${1:\"${2:Submit}\"}, to: ${3:\"${4:/users}\"}, method: ${5::delete} %>"
41 |   },
42 |   "ff": {
43 |     "prefix": "ff",
44 |     "description": "form_for",
45 |     "body": [
46 |       "<%= form_for @changeset, ${1:\"${2:/users}\"}, fn f -> %>",
47 |       "\t\t$0",
48 |       "",
49 |       "\t<%= submit \"Submit\" %>",
50 |       "<% end %>"
51 |     ]
52 |   },
53 |   "gt": {
54 |     "prefix": "gt",
55 |     "description": "gettext",
56 |     "body": "<%= gettext(\"${0:$TM_SELECTED_TEXT}\") %>"
57 |   }
58 | }
59 | 


--------------------------------------------------------------------------------
/lua/user/dap.lua:
--------------------------------------------------------------------------------
 1 | -- local dap_status_ok, dap = pcall(require, "dap")
 2 | -- if not dap_status_ok then
 3 | --   return
 4 | -- end
 5 | --
 6 | -- local dap_ui_status_ok, dapui = pcall(require, "dapui")
 7 | -- if not dap_ui_status_ok then
 8 | --   return
 9 | -- end
10 | --
11 | -- local dap_install_status_ok, dap_install = pcall(require, "dap-install")
12 | -- if not dap_install_status_ok then
13 | --   return
14 | -- end
15 | --
16 | -- dap_install.setup {}
17 | --
18 | -- dap_install.config("python", {})
19 | -- -- add other configs here
20 | --
21 | -- dapui.setup {
22 | --   sidebar = {
23 | --     elements = {
24 | --       {
25 | --         id = "scopes",
26 | --         size = 0.25, -- Can be float or integer > 1
27 | --       },
28 | --       { id = "breakpoints", size = 0.25 },
29 | --     },
30 | --     size = 40,
31 | --     position = "right", -- Can be "left", "right", "top", "bottom"
32 | --   },
33 | --   tray = {
34 | --     elements = {},
35 | --   },
36 | -- }
37 | --
38 | -- vim.fn.sign_define("DapBreakpoint", { text = "", texthl = "DiagnosticSignError", linehl = "", numhl = "" })
39 | --
40 | -- dap.listeners.after.event_initialized["dapui_config"] = function()
41 | --   dapui.open()
42 | -- end
43 | --
44 | -- dap.listeners.before.event_terminated["dapui_config"] = function()
45 | --   dapui.close()
46 | -- end
47 | --
48 | -- dap.listeners.before.event_exited["dapui_config"] = function()
49 | --   dapui.close()
50 | -- end
51 | 


--------------------------------------------------------------------------------
/cool_snippets/javascript-jasmine-arrow.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "des": {
 3 |     "prefix": "des",
 4 |     "description": "Describe (js)",
 5 |     "body": [
 6 |       "describe('${1:description}', () => {",
 7 |       "\t$0",
 8 |       "\\});"
 9 |     ],
10 |     "luasnip": {
11 |       "priority": -50
12 |     }
13 |   },
14 |   "it": {
15 |     "prefix": "it",
16 |     "description": "it (js)",
17 |     "body": [
18 |       "it('${1:description}', () => {",
19 |       "\t$0",
20 |       "\\});"
21 |     ]
22 |   },
23 |   "bef": {
24 |     "prefix": "bef",
25 |     "description": "before each (js)",
26 |     "body": [
27 |       "beforeEach(() => {",
28 |       "\t$0",
29 |       "\\});"
30 |     ]
31 |   },
32 |   "aft": {
33 |     "prefix": "aft",
34 |     "description": "after each (js)",
35 |     "body": [
36 |       "afterEach(() => {",
37 |       "\t$0",
38 |       "\\});"
39 |     ]
40 |   },
41 |   "befa": {
42 |     "prefix": "befa",
43 |     "description": "before all (js)",
44 |     "body": [
45 |       "beforeAll(() => {",
46 |       "\t$0",
47 |       "\\});"
48 |     ]
49 |   },
50 |   "afta": {
51 |     "prefix": "afta",
52 |     "description": "after all (js)",
53 |     "body": [
54 |       "afterAll(() => {",
55 |       "\t$0",
56 |       "\\});"
57 |     ]
58 |   },
59 |   "ru": {
60 |     "prefix": "ru",
61 |     "description": "runs (js)",
62 |     "body": [
63 |       "runs(() => {",
64 |       "\t$0",
65 |       "\\});"
66 |     ]
67 |   }
68 | }
69 | 


--------------------------------------------------------------------------------
/cool_snippets/javascript_react.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "useE": {
 3 |     "prefix": "useE",
 4 |     "description": "useEffect Hook",
 5 |     "body": [
 6 |       "useEffect(() => {",
 7 |       "\t${1:$0}",
 8 |       "\t\t\\}$2)"
 9 |     ]
10 |   },
11 |   "useC": {
12 |     "prefix": "useC",
13 |     "description": "useContext Hook",
14 |     "body": "const ${1:context} = useContext($2)"
15 |   },
16 |   "useRe": {
17 |     "prefix": "useRe",
18 |     "description": "useReducer Hook",
19 |     "body": "const [${3:state}, ${4:dispatch}] = useReducer(${5:reducer}, ${2:initial_value})"
20 |   },
21 |   "useCB": {
22 |     "prefix": "useCB",
23 |     "description": "useCallback(fn, inputs)",
24 |     "body": [
25 |       "const ${1:callback} = useCallback(($2)) => ${3:{",
26 |       "\t$4",
27 |       "\\}}, [$5])"
28 |     ]
29 |   },
30 |   "useM": {
31 |     "prefix": "useM",
32 |     "description": "useMemo(fn, inputs)",
33 |     "body": [
34 |       "const ${1:memorized} = useMemo(() => ${2:{",
35 |       "\t$3",
36 |       "\\}}, [$4])"
37 |     ]
38 |   },
39 |   "useR": {
40 |     "prefix": "useR",
41 |     "description": "useRef(defaultValue)",
42 |     "body": "const ${1:ref} = useRef(${2:null})"
43 |   },
44 |   "ir": {
45 |     "prefix": "ir",
46 |     "description": "import React",
47 |     "body": "import React from \"react\""
48 |   },
49 |   "irc": {
50 |     "prefix": "irc",
51 |     "description": "import React and Component",
52 |     "body": "import React, { Component \\} from \"react\""
53 |   }
54 | }
55 | 


--------------------------------------------------------------------------------
/Session.vim:
--------------------------------------------------------------------------------
 1 | let SessionLoad = 1
 2 | let s:so_save = &g:so | let s:siso_save = &g:siso | setg so=0 siso=0 | setl so=-1 siso=-1
 3 | let v:this_session=expand("<sfile>:p")
 4 | silent only
 5 | silent tabonly
 6 | cd ~/.config/nvim
 7 | if expand('%') == '' && !&modified && line('$') <= 1 && getline(1) == ''
 8 |   let s:wipebuf = bufnr('%')
 9 | endif
10 | let s:shortmess_save = &shortmess
11 | if &shortmess =~ 'A'
12 |   set shortmess=aoOA
13 | else
14 |   set shortmess=aoO
15 | endif
16 | badd +0 lua/user/lsp/handlers.lua
17 | argglobal
18 | %argdel
19 | edit lua/user/lsp/handlers.lua
20 | argglobal
21 | setlocal fdm=manual
22 | setlocal fde=0
23 | setlocal fmr={{{,}}}
24 | setlocal fdi=#
25 | setlocal fdl=0
26 | setlocal fml=1
27 | setlocal fdn=20
28 | setlocal fen
29 | silent! normal! zE
30 | let &fdl = &fdl
31 | let s:l = 1 - ((0 * winheight(0) + 21) / 42)
32 | if s:l < 1 | let s:l = 1 | endif
33 | keepjumps exe s:l
34 | normal! zt
35 | keepjumps 1
36 | normal! 0
37 | tabnext 1
38 | if exists('s:wipebuf') && len(win_findbuf(s:wipebuf)) == 0 && getbufvar(s:wipebuf, '&buftype') isnot# 'terminal'
39 |   silent exe 'bwipe ' . s:wipebuf
40 | endif
41 | unlet! s:wipebuf
42 | set winheight=1 winwidth=20
43 | let &shortmess = s:shortmess_save
44 | let s:sx = expand("<sfile>:p:r")."x.vim"
45 | if filereadable(s:sx)
46 |   exe "source " . fnameescape(s:sx)
47 | endif
48 | let &g:so = s:so_save | let &g:siso = s:siso_save
49 | set hlsearch
50 | nohlsearch
51 | doautoall SessionLoadPost
52 | unlet SessionLoad
53 | " vim: set ft=vim :
54 | 


--------------------------------------------------------------------------------
/cool_snippets/julia.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "docf": {
 3 |     "prefix": "docf",
 4 |     "description": "function documentation",
 5 |     "body": [
 6 |       "#' @description",
 7 |       "#'",
 8 |       "#' ${1:function description}",
 9 |       "#'",
10 |       "#' ${2:@param ${3:name}::${4:Type} ${5:Description}}",
11 |       "#'",
12 |       "#' ${6:@returns ${7:name}::${8:Type} ${9:Description}}",
13 |       "#'",
14 |       "#' @examples",
15 |       "#'",
16 |       "#' ${10: function call examples}"
17 |     ]
18 |   },
19 |   "doct": {
20 |     "prefix": "doct",
21 |     "description": "type definition",
22 |     "body": [
23 |       "#' @description",
24 |       "#'",
25 |       "#' ${1:type description}",
26 |       "#'",
27 |       "#' ${2:@field ${3:name}::${4:Type} ${5:Description}}",
28 |       "#'",
29 |       "#' @examples",
30 |       "#'",
31 |       "#' ${10: constructor examples}"
32 |     ]
33 |   },
34 |   "par": {
35 |     "prefix": "par",
36 |     "description": "function parameter documentation",
37 |     "body": "#' @param ${1:name}::${2:Type} ${0:Description}"
38 |   },
39 |   "fld": {
40 |     "prefix": "fld",
41 |     "description": "type field documentation",
42 |     "body": "#' @field ${1:name}::${2:Type} ${0:Description}"
43 |   },
44 |   "deb": {
45 |     "prefix": "deb",
46 |     "description": "Debugger breakpoint",
47 |     "body": "Main.@bp"
48 |   },
49 |   "inf": {
50 |     "prefix": "inf",
51 |     "description": "Infiltrator breakpoint",
52 |     "body": "Main.@infiltrate"
53 |   }
54 | }
55 | 


--------------------------------------------------------------------------------
/cool_snippets/tcl.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "for": {
 3 |     "prefix": "for",
 4 |     "description": "for... (for)",
 5 |     "body": [
 6 |       "for {${1:set i 0}\\} {${2:\\$i < \\$n}\\} {${3:incr i}\\} {",
 7 |       "\t$4",
 8 |       "\\}",
 9 |       ""
10 |     ],
11 |     "luasnip": {
12 |       "priority": -50
13 |     }
14 |   },
15 |   "foreach": {
16 |     "prefix": "foreach",
17 |     "description": "foreach... (foreach)",
18 |     "body": [
19 |       "foreach ${1:var} ${2:\\$list} {",
20 |       "\t$3",
21 |       "\\}",
22 |       ""
23 |     ]
24 |   },
25 |   "if": {
26 |     "prefix": "if",
27 |     "description": "if... (if)",
28 |     "body": [
29 |       "if {${1:condition}\\} {",
30 |       "\t$2",
31 |       "\\}",
32 |       ""
33 |     ]
34 |   },
35 |   "proc": {
36 |     "prefix": "proc",
37 |     "description": "proc... (proc)",
38 |     "body": [
39 |       "proc ${1:name} {${2:args}\\} \\",
40 |       "{",
41 |       "\t$3",
42 |       "\\}",
43 |       ""
44 |     ]
45 |   },
46 |   "switch": {
47 |     "prefix": "switch",
48 |     "description": "switch... (switch)",
49 |     "body": [
50 |       "switch ${1:-exact} -- ${2:\\$var} {",
51 |       "\t${3:match} {",
52 |       "\t\t$4",
53 |       "\t\\}",
54 |       "\tdefault {$5\\}",
55 |       "\\}",
56 |       ""
57 |     ]
58 |   },
59 |   "while": {
60 |     "prefix": "while",
61 |     "description": "while... (while)",
62 |     "body": [
63 |       "while {${1:condition}\\} {",
64 |       "\t$2",
65 |       "\\}",
66 |       ""
67 |     ]
68 |   }
69 | }
70 | 


--------------------------------------------------------------------------------
/lua/user/project.lua:
--------------------------------------------------------------------------------
 1 | local status, project = pcall(require, "project_nvim")
 2 | 
 3 | if not status then
 4 | 	return
 5 | end
 6 | 
 7 | project.setup({
 8 | 	-- Manual mode doesn't automatically change your root directory, so you have
 9 | 	-- the option to manually do so using `:ProjectRoot` command.
10 | 	manual_mode = false,
11 | 
12 | 	-- Methods of detecting the root directory. **"lsp"** uses the native neovim
13 | 	-- lsp, while **"pattern"** uses vim-rooter like glob pattern matching. Here
14 | 	-- order matters: if one is not detected, the other is used as fallback. You
15 | 	-- can also delete or rearangne the detection methods.
16 | 	detection_methods = { "lsp", "pattern" },
17 | 
18 | 	-- All the patterns used to detect root dir, when **"pattern"** is in
19 | 	-- detection_methods
20 | 	patterns = { ".git", "_darcs", ".hg", ".bzr", ".svn", "Makefile", "package.json", "go.mod" },
21 | 
22 | 	-- Table of lsp clients to ignore by name
23 | 	-- eg: { "efm", ... }
24 | 	ignore_lsp = {},
25 | 
26 | 	-- Don't calculate root dir on specific directories
27 | 	-- Ex: { "~/.cargo/*", ... }
28 | 	exclude_dirs = {},
29 | 
30 | 	-- Show hidden files in telescope
31 | 	show_hidden = false,
32 | 
33 | 	-- When set to false, you will get a message when project.nvim changes your
34 | 	-- directory.
35 | 	silent_chdir = true,
36 | 
37 | 	-- What scope to change the directory, valid options are
38 | 	-- * global (default)
39 | 	-- * tab
40 | 	-- * win
41 | 	scope_chdir = "global",
42 | 
43 | 	-- Path where project.nvim will store the project history for use in
44 | 	-- telescope
45 | 	datapath = vim.fn.stdpath("data"),
46 | })
47 | 


--------------------------------------------------------------------------------
/cool_snippets/javascript-jsdoc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "/*": {
 3 |     "prefix": "/*",
 4 |     "description": "A JSDoc comment",
 5 |     "body": [
 6 |       "/**",
 7 |       " * ${1:$TM_SELECTED_TEXT}$0",
 8 |       " */"
 9 |     ],
10 |     "luasnip": {
11 |       "priority": -50
12 |     }
13 |   },
14 |   "@li": {
15 |     "prefix": "@li",
16 |     "description": "@license Description",
17 |     "body": "@license ${1:MIT}$0"
18 |   },
19 |   "@ver": {
20 |     "prefix": "@ver",
21 |     "description": "@version Semantic version",
22 |     "body": "@version ${1:0.1.0}$0"
23 |   },
24 |   "@fileo": {
25 |     "prefix": "@fileo",
26 |     "description": "@fileoverview Description",
27 |     "body": [
28 |       "/**",
29 |       " * @fileoverview ${1:${TM_SELECTED_TEXT:A description of the file}}$0",
30 |       " */"
31 |     ]
32 |   },
33 |   "@constr": {
34 |     "prefix": "@constr",
35 |     "description": "@constructor",
36 |     "body": "@constructor"
37 |   },
38 |   "@p": {
39 |     "prefix": "@p",
40 |     "description": "@param {Type} varname Description",
41 |     "body": "@param {${1:Type}\\} ${2:varname} ${3:Description}"
42 |   },
43 |   "@ret": {
44 |     "prefix": "@ret",
45 |     "description": "@return {Type} Description",
46 |     "body": "@return {${1:Type}\\} ${2:Description}"
47 |   },
48 |   "@pri": {
49 |     "prefix": "@pri",
50 |     "description": "@private",
51 |     "body": "@private"
52 |   },
53 |   "@over": {
54 |     "prefix": "@over",
55 |     "description": "@override",
56 |     "body": "@override"
57 |   },
58 |   "@pro": {
59 |     "prefix": "@pro",
60 |     "description": "@protected",
61 |     "body": "@protected"
62 |   }
63 | }
64 | 


--------------------------------------------------------------------------------
/cool_snippets/texmath.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "eqnn": {
 3 |     "prefix": "eqnn",
 4 |     "description": "Equation without a number",
 5 |     "body": [
 6 |       "\\begin{equation*\\}",
 7 |       "\t${0:$TM_SELECTED_TEXT}",
 8 |       "\\end{equation*\\}"
 9 |     ],
10 |     "luasnip": {
11 |       "priority": -50
12 |     }
13 |   },
14 |   "al": {
15 |     "prefix": "al",
16 |     "description": "Align",
17 |     "body": [
18 |       "\\begin{align\\}",
19 |       "\t${0:$TM_SELECTED_TEXT}",
20 |       "\\end{align\\}"
21 |     ]
22 |   },
23 |   "alnn": {
24 |     "prefix": "alnn",
25 |     "description": "Align without a number",
26 |     "body": [
27 |       "\\begin{align*\\}",
28 |       "\t${0:$TM_SELECTED_TEXT}",
29 |       "\\end{align*\\}"
30 |     ]
31 |   },
32 |   "eqa": {
33 |     "prefix": "eqa",
34 |     "description": "Equation array",
35 |     "body": [
36 |       "\\begin{eqnarray\\}",
37 |       "\t${1:$TM_SELECTED_TEXT} & ${2:$TM_SELECTED_TEXT} & ${0:$TM_SELECTED_TEXT}",
38 |       "\\end{eqnarray\\}"
39 |     ]
40 |   },
41 |   "eqann": {
42 |     "prefix": "eqann",
43 |     "description": "Equation array without a number",
44 |     "body": [
45 |       "\\begin{eqnarray*\\}",
46 |       "\t${1:$TM_SELECTED_TEXT} & ${2:$TM_SELECTED_TEXT} & ${0:$TM_SELECTED_TEXT}",
47 |       "\\end{eqnarray*\\}"
48 |     ]
49 |   },
50 |   "dv": {
51 |     "prefix": "dv",
52 |     "description": "Derivative",
53 |     "body": "\\dv[${1:$TM_SELECTED_TEXT}]{$2\\}{$3\\}"
54 |   },
55 |   "pdv": {
56 |     "prefix": "pdv",
57 |     "description": "Partial Derivative",
58 |     "body": "\\pdv[${1:$TM_SELECTED_TEXT}]{$2\\}{$3\\}"
59 |   },
60 |   "SI": {
61 |     "prefix": "SI",
62 |     "description": "SI-Unit",
63 |     "body": "\\SI{${1:$TM_SELECTED_TEXT}\\}{$2\\}"
64 |   }
65 | }
66 | 


--------------------------------------------------------------------------------
/init.lua:
--------------------------------------------------------------------------------
 1 | require("user.options")
 2 | require("user.plugins")
 3 | require("user.keymaps")
 4 | require("user.lsp")
 5 | require("user.treesitter")
 6 | require("user.cmp")
 7 | require("user.autocommands")
 8 | require("user.colorscheme")
 9 | require("user.telescope-cfg")
10 | require("user.gitsigns")
11 | require("user.autopairs")
12 | -- require("user.comment")
13 | require("user.nvim-tree")
14 | require("user.bufferline")
15 | require("user.lualine")
16 | require("user.toggleterm")
17 | require("user.project")
18 | -- require("user.impatient")
19 | vim.loader.enable()
20 | require("user.illuminate")
21 | require("user.indentline")
22 | require("user.alpha")
23 | require("user.luasnip_setup")
24 | -- require("user.miniIntentscope")
25 | -- require("user.copilot")
26 | require("user.codeium")
27 | require("user.commands")
28 | -- require("user.modicator")
29 | require("user.navic")
30 | require("user.noice")
31 | -- require("user.conform")
32 | --require("user.notify")
33 | -- require("user.research")
34 | require("user.todo-comments")
35 | -- require("user.trouble")
36 | require("user.winbar")
37 | -- require("user.shade")
38 | -- require "user.dap"
39 | -- require 'user.coqCmp'
40 | require("user.whichKey")
41 | -- require("user.import-cost")
42 | -- require("user.typescript")
43 | -- require "user.tabout"
44 | require("scope").setup()
45 | require("user.comment")
46 | require("user.colorizer")
47 | require("user.nvim-ts-autotag")
48 | -- vim.cmd(":COQnow --shut-up")
49 | require("pets").setup({})
50 | vim.cmd([[:set laststatus=3]])
51 | vim.cmd([[colorscheme tokyonight-night]])
52 | -- vim.cmd([[:PetsNew newPet]])
53 | -- require("flirt").setup()
54 | vim.api.nvim_set_hl(0, "DiagnosticUnnecessary", { fg = "#6d7493" })
55 | vim.api.nvim_set_hl(0, "IlluminateWordRead", { bg = "#333752" })
56 | 


--------------------------------------------------------------------------------
/cool_snippets/soy.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "ns": {
 3 |     "prefix": "ns",
 4 |     "description": "Namespace",
 5 |     "body": "{namespace ${1:name}\\}",
 6 |     "luasnip": {
 7 |       "priority": -50
 8 |     }
 9 |   },
10 |   "msg": {
11 |     "prefix": "msg",
12 |     "description": "Message",
13 |     "body": [
14 |       "{msg desc=\"${1:description}\"\\}",
15 |       "\t$0",
16 |       "{/msg\\}"
17 |     ]
18 |   },
19 |   "let": {
20 |     "prefix": "let",
21 |     "description": "let command",
22 |     "body": "{let \\$${1:identifier}: ${2:expression} /\\}"
23 |   },
24 |   "if": {
25 |     "prefix": "if",
26 |     "description": "if .. (if)",
27 |     "body": [
28 |       "{if ${1:expression}\\}",
29 |       "\t$0",
30 |       "{/if\\}"
31 |     ]
32 |   },
33 |   "ife": {
34 |     "prefix": "ife",
35 |     "description": "if .. else (ife)",
36 |     "body": [
37 |       "{if ${1:expression}\\}",
38 |       "\t$2",
39 |       "{else\\}",
40 |       "\t$0",
41 |       "{/if\\}"
42 |     ]
43 |   },
44 |   "eli": {
45 |     "prefix": "eli",
46 |     "description": "else if .. (eli)",
47 |     "body": [
48 |       "{elif ${1:expression}\\}",
49 |       "\t$0"
50 |     ]
51 |   },
52 |   "fore": {
53 |     "prefix": "fore",
54 |     "description": "foreach command",
55 |     "body": [
56 |       "{foreach \\$${1:var} in ${2:ref}\\}",
57 |       "\t$0",
58 |       "{/foreach\\}"
59 |     ]
60 |   },
61 |   "for": {
62 |     "prefix": "for",
63 |     "description": "for command",
64 |     "body": [
65 |       "{for \\$${1:var} in range(${2:rangeexpr})\\}",
66 |       "\t$0",
67 |       "{/for\\}"
68 |     ]
69 |   },
70 |   "call": {
71 |     "prefix": "call",
72 |     "description": "template call",
73 |     "body": [
74 |       "{call ${1:tmpl}\\}",
75 |       "\t$0",
76 |       "{/call\\}"
77 |     ]
78 |   }
79 | }
80 | 


--------------------------------------------------------------------------------
/cool_snippets/bib.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "online": {
 3 |     "prefix": "online",
 4 |     "description": "Online resource",
 5 |     "body": [
 6 |       "@online{${1:name},",
 7 |       "\tauthor={${2:author}\\},",
 8 |       "\ttitle={${3:title}\\},",
 9 |       "\tdate={${4:date}\\},",
10 |       "\turl={${5:url}\\}",
11 |       "\\}",
12 |       "$0"
13 |     ],
14 |     "luasnip": {
15 |       "priority": -50
16 |     }
17 |   },
18 |   "article": {
19 |     "prefix": "article",
20 |     "description": "Article reference",
21 |     "body": [
22 |       "@article{${1:name},",
23 |       "\tauthor={${2:author}\\},",
24 |       "\ttitle={${3:title}\\},",
25 |       "\tjournaltitle={${4:journal}\\},",
26 |       "\tvolume={${5:NN}\\},",
27 |       "\tnumber={${6:NN}\\},",
28 |       "\tyear={${7:YYYY}\\},",
29 |       "\tpages={${8:NN}--${9:NN}\\}",
30 |       "\\}",
31 |       "$0"
32 |     ]
33 |   },
34 |   "book": {
35 |     "prefix": "book",
36 |     "description": "Book reference",
37 |     "body": [
38 |       "@book{${1:name},",
39 |       "\tauthor={${2:author}\\},",
40 |       "\ttitle={${3:title}\\},",
41 |       "\tsubtitle={${4:subtitle}\\},",
42 |       "\tyear={${5:YYYY}\\},",
43 |       "\tlocation={${6:somewhere}\\},",
44 |       "\tpublisher={${7:publisher}\\},",
45 |       "\tpages={${8:NN}--${9:NN}\\}",
46 |       "\\}",
47 |       "$0"
48 |     ]
49 |   },
50 |   "inb": {
51 |     "prefix": "inb",
52 |     "description": "In Book reference",
53 |     "body": [
54 |       "@inbook{${1:name},",
55 |       "\tauthor={${2:author}\\},",
56 |       "\ttitle={${3:title}\\},",
57 |       "\tsubtitle={${4:subtitle}\\},",
58 |       "\tbooktitle={${5:book}\\},",
59 |       "\teditor={${6:editor}\\},",
60 |       "\tyear={${7:YYYY}\\},",
61 |       "\tlocation={${8:somewhere}\\},",
62 |       "\tpublisher={${9:publisher}\\},",
63 |       "\tpages={${10:NN}--${11:NN}\\}",
64 |       "\\}",
65 |       "$0"
66 |     ]
67 |   }
68 | }
69 | 


--------------------------------------------------------------------------------
/cool_snippets/javascript-node.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "#!": {
 3 |     "prefix": "#!",
 4 |     "description": "#!/usr/bin/env node",
 5 |     "body": "#!/usr/bin/env node",
 6 |     "luasnip": {
 7 |       "priority": -50
 8 |     }
 9 |   },
10 |   "ex": {
11 |     "prefix": "ex",
12 |     "description": "module.exports",
13 |     "body": "module.exports = $1;"
14 |   },
15 |   "hcs": {
16 |     "prefix": "hcs",
17 |     "description": "http.createServer",
18 |     "body": "http.createServer($1).listen($2);"
19 |   },
20 |   "ncs": {
21 |     "prefix": "ncs",
22 |     "description": "net.createServer",
23 |     "body": [
24 |       "net.createServer(function(${1:socket}){",
25 |       "\t$1.on('data', function(${3:data}){",
26 |       "\t\t$4",
27 |       "\t\\});",
28 |       "\t$1.on('end', function(){",
29 |       "\t\t$5",
30 |       "\t\\});",
31 |       "\\}).listen(${6:8124});"
32 |     ]
33 |   },
34 |   "pipe": {
35 |     "prefix": "pipe",
36 |     "description": "pipe",
37 |     "body": "pipe(${1:stream})$2"
38 |   },
39 |   "eget": {
40 |     "prefix": "eget",
41 |     "description": "express GET",
42 |     "body": "${1:app}.get('$2', $3);"
43 |   },
44 |   "epost": {
45 |     "prefix": "epost",
46 |     "description": "express POST",
47 |     "body": "${1:app}.post('$2', $3);"
48 |   },
49 |   "eput": {
50 |     "prefix": "eput",
51 |     "description": "express PUT",
52 |     "body": "${1:app}.put('$2', $3);"
53 |   },
54 |   "edelete": {
55 |     "prefix": "edelete",
56 |     "description": "express DELETE",
57 |     "body": "${1:app}.delete('$2', $3);"
58 |   },
59 |   "stdout": {
60 |     "prefix": "stdout",
61 |     "description": "stdout",
62 |     "body": "process.stdout"
63 |   },
64 |   "stdin": {
65 |     "prefix": "stdin",
66 |     "description": "stdin",
67 |     "body": "process.stdin"
68 |   },
69 |   "stderr": {
70 |     "prefix": "stderr",
71 |     "description": "stderr",
72 |     "body": "process.stderr"
73 |   }
74 | }
75 | 


--------------------------------------------------------------------------------
/lua/user/autocommands.lua:
--------------------------------------------------------------------------------
 1 | vim.api.nvim_create_autocmd({ "FileType" }, {
 2 | 	pattern = { "qf", "help", "man", "lspinfo", "spectre_panel" },
 3 | 	callback = function()
 4 | 		vim.cmd([[
 5 |       nnoremap <silent> <buffer> q :close<CR> 
 6 |       set nobuflisted 
 7 |     ]])
 8 | 	end,
 9 | })
10 | 
11 | vim.api.nvim_create_autocmd({ "FileType" }, {
12 | 	pattern = { "gitcommit"},
13 | 	callback = function()
14 | 		vim.opt_local.wrap = true
15 | 		vim.opt_local.spell = true
16 | 	end,
17 | })
18 | 
19 | vim.api.nvim_create_autocmd({ "FileType" }, {
20 | 	pattern = { "markdown" },
21 | 	callback = function()
22 | 		vim.opt_local.wrap = true
23 | 		vim.opt_local.spell = true
24 | 	end,
25 | })
26 | 
27 | 
28 | vim.cmd("autocmd BufEnter * ++nested if winnr('$') == 1 && bufname() == 'NvimTree_' . tabpagenr() | quit | endif")
29 | -- vim.api.nvim_create_autocmd({ "BufEnter" }, {
30 | --   callback = function()
31 | --     vim.cmd [[
32 | --       if winnr('$') == 1 && bufname() == 'NvimTree_' . tabpagenr() | quit | endif
33 | --     ]]
34 | --   end,
35 | -- })
36 | 
37 | vim.api.nvim_create_autocmd({ "VimResized" }, {
38 | 	callback = function()
39 | 		vim.cmd("tabdo wincmd =")
40 | 	end,
41 | })
42 | 
43 | vim.api.nvim_create_autocmd({ "CmdWinEnter" }, {
44 | 	callback = function()
45 | 		vim.cmd("quit")
46 | 	end,
47 | })
48 | vim.api.nvim_create_autocmd({ "BufWinEnter" }, {
49 | 	callback = function()
50 | 		vim.cmd("set formatoptions-=cro")
51 | 	end,
52 | })
53 | 
54 | vim.api.nvim_create_autocmd({ "TextYankPost" }, {
55 | 	callback = function()
56 | 		vim.highlight.on_yank({ higroup = "Visual", timeout = 200 })
57 | 	end,
58 | })
59 | 
60 | vim.api.nvim_create_autocmd({ "BufWritePost" }, {
61 | 	pattern = { "*.java" },
62 | 	callback = function()
63 | 		vim.lsp.codelens.refresh()
64 | 	end,
65 | })
66 | 
67 | vim.api.nvim_create_autocmd({ "VimEnter" }, {
68 | 	callback = function()
69 | 		vim.cmd("hi link illuminatedWord LspReferenceText")
70 | 	end,
71 | })
72 | 


--------------------------------------------------------------------------------
/cool_snippets/c.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "def": {
 3 |     "prefix": "def",
 4 |     "description": "#define ...",
 5 |     "body": "#define $1",
 6 |     "luasnip": {
 7 |       "priority": -50
 8 |     }
 9 |   },
10 |   "#if": {
11 |     "prefix": "#if",
12 |     "description": "#if #endif",
13 |     "body": [
14 |       "#if ${1:0}",
15 |       "$TM_SELECTED_TEXT$0",
16 |       "#endif"
17 |     ]
18 |   },
19 |   "mark": {
20 |     "prefix": "mark",
21 |     "description": "#pragma mark (mark)",
22 |     "body": [
23 |       "#if 0",
24 |       "${1:#pragma mark -",
25 |       "}#pragma mark $2",
26 |       "#endif",
27 |       "",
28 |       "$0"
29 |     ]
30 |   },
31 |   "main": {
32 |     "prefix": "main",
33 |     "description": "main() (main)",
34 |     "body": [
35 |       "int main(int argc, char *argv[])",
36 |       "{",
37 |       "\t$TM_SELECTED_TEXT$0",
38 |       "\treturn 0;",
39 |       "\\}"
40 |     ]
41 |   },
42 |   "for": {
43 |     "prefix": "for",
44 |     "description": "for loop (for)",
45 |     "body": [
46 |       "for (${2:i} = 0; $2 < ${1:count}; ${3:++$2}) {",
47 |       "\t$TM_SELECTED_TEXT$0",
48 |       "\\}"
49 |     ]
50 |   },
51 |   "fori": {
52 |     "prefix": "fori",
53 |     "description": "for int loop (fori)",
54 |     "body": [
55 |       "for (${4:int} ${2:i} = 0; $2 < ${1:count}; ${3:++$2}) {",
56 |       "\t$TM_SELECTED_TEXT$0",
57 |       "\\}"
58 |     ]
59 |   },
60 |   "eli": {
61 |     "prefix": "eli",
62 |     "description": "else if .. (eli)",
63 |     "body": [
64 |       "else if (${1:/* condition */}) {",
65 |       "\t$TM_SELECTED_TEXT$0",
66 |       "\\}"
67 |     ]
68 |   },
69 |   "fun": {
70 |     "prefix": "fun",
71 |     "description": "function",
72 |     "body": [
73 |       "${1:void} ${2:function_name}($3)",
74 |       "{",
75 |       "\t$TM_SELECTED_TEXT$0",
76 |       "\\}"
77 |     ]
78 |   },
79 |   "fund": {
80 |     "prefix": "fund",
81 |     "description": "function declaration",
82 |     "body": "${1:void} ${2:function_name}($3);"
83 |   }
84 | }
85 | 


--------------------------------------------------------------------------------
/cool_snippets/coffee.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "if": {
 3 |     "prefix": "if",
 4 |     "description": "If",
 5 |     "body": [
 6 |       "if ${1:condition}",
 7 |       "\t${0:# body...}"
 8 |     ]
 9 |   },
10 |   "ife": {
11 |     "prefix": "ife",
12 |     "description": "If .. Else",
13 |     "body": [
14 |       "if ${1:condition}",
15 |       "\t${2:# body...}",
16 |       "else",
17 |       "\t${3:# body...}"
18 |     ]
19 |   },
20 |   "elif": {
21 |     "prefix": "elif",
22 |     "description": "Else if",
23 |     "body": [
24 |       "else if ${1:condition}",
25 |       "\t${0:# body...}"
26 |     ]
27 |   },
28 |   "ifte": {
29 |     "prefix": "ifte",
30 |     "description": "Ternary if",
31 |     "body": "if ${1:condition} then ${2:value} else ${3:other}"
32 |   },
33 |   "unl": {
34 |     "prefix": "unl",
35 |     "description": "Unless",
36 |     "body": "${1:action} unless ${2:condition}"
37 |   },
38 |   "fora": {
39 |     "prefix": "fora",
40 |     "description": "Array Comprehension",
41 |     "body": [
42 |       "for ${1:name} in ${2:array}",
43 |       "\t${0:# body...}"
44 |     ]
45 |   },
46 |   "foro": {
47 |     "prefix": "foro",
48 |     "description": "Object Comprehension",
49 |     "body": [
50 |       "for ${1:key}, ${2:value} of ${3:Object}",
51 |       "\t${0:# body...}"
52 |     ]
53 |   },
54 |   "swi": {
55 |     "prefix": "swi",
56 |     "description": "Switch",
57 |     "body": [
58 |       "switch ${1:object}",
59 |       "\twhen ${2:value}",
60 |       "\t\t${3:# body...}",
61 |       "\telse",
62 |       "\t\t$0"
63 |     ]
64 |   },
65 |   "try": {
66 |     "prefix": "try",
67 |     "description": "Try .. Catch",
68 |     "body": [
69 |       "try",
70 |       "\t$1",
71 |       "catch ${2:error}",
72 |       "\t$3"
73 |     ]
74 |   },
75 |   "#": {
76 |     "prefix": "#",
77 |     "description": "Interpolated Code",
78 |     "body": "#{$1\\}$0"
79 |   },
80 |   "log": {
81 |     "prefix": "log",
82 |     "description": "Log",
83 |     "body": "console.log ${1:\"${2:msg}\"}"
84 |   },
85 |   "kv": {
86 |     "prefix": "kv",
87 |     "description": "Key:value for object",
88 |     "body": "${1:key}:${2:value}"
89 |   }
90 | }
91 | 


--------------------------------------------------------------------------------
/lua/user/navic.lua:
--------------------------------------------------------------------------------
 1 | local present, navic = pcall(require, "nvim-navic")
 2 | 
 3 | if not present then
 4 |   return
 5 | end
 6 | 
 7 | local icons = require "user.icons"
 8 | 
 9 | navic.setup {
10 |   -- icons = {
11 |   --   File = " ",
12 |   --   Module = " ",
13 |   --   Namespace = " ",
14 |   --   Package = " ",
15 |   --   Class = " ",
16 |   --   Method = " ",
17 |   --   Property = " ",
18 |   --   Field = " ",
19 |   --   Constructor = " ",
20 |   --   Enum = "練",
21 |   --   Interface = "練",
22 |   --   Function = " ",
23 |   --   Variable = " ",
24 |   --   Constant = " ",
25 |   --   String = " ",
26 |   --   Number = " ",
27 |   --   Boolean = "◩ ",
28 |   --   Array = " ",
29 |   --   Object = " ",
30 |   --   Key = " ",
31 |   --   Null = "ﳠ ",
32 |   --   EnumMember = " ",
33 |   --   Struct = " ",
34 |   --   Event = " ",
35 |   --   Operator = " ",
36 |   --   TypeParameter = " ",
37 |   -- },
38 | 
39 |   -- icons = {
40 |   --   File = icons.kind.File,
41 |   --   Module = icons.kind.Module,
42 |   --   Namespace = icons.kind.Namespace,
43 |   --   Package = icons.kind.Package,
44 |   --   Class = icons.kind.Class,
45 |   --   Method = icons.kind.Method,
46 |   --   Property = icons.kind.Property,
47 |   --   Field = icons.kind.Field,
48 |   --   Constructor = icons.kind.Constructor,
49 |   --   Enum = icons.kind.Enum,
50 |   --   Interface = icons.kind.Interface,
51 |   --   Function = icons.kind.Function,
52 |   --   Variable = icons.kind.Variable,
53 |   --   Constant = icons.kind.Constant,
54 |   --   String = icons.kind.String,
55 |   --   Number = icons.kind.Number,
56 |   --   Boolean = icons.kind.Boolean,
57 |   --   Array = icons.kind.Array,
58 |   --   Object = icons.kind.Object,
59 |   --   Key = " ",
60 |   --   Null = "ﳠ ",
61 |   --   EnumMember = " ",
62 |   --   Struct = " ",
63 |   --   Event = " ",
64 |   --   Operator = " ",
65 |   --   TypeParameter = " ",
66 |   -- },
67 | 
68 |   icons = icons.kind,
69 |   highlight = true,
70 |   separator = " > ",
71 |   depth_limit = 0,
72 |   depth_limit_indicator = "..",
73 | }
74 | 
75 | vim.opt.winbar = "%{%v:lua.require'nvim-navic'.get_location()%}"
76 | 


--------------------------------------------------------------------------------
/cool_snippets/eruby.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "layout": {
 3 |     "prefix": "layout",
 4 |     "description": "layout",
 5 |     "body": "layout \"${1:template_name}\"${2:${3:, :only => ${4:[:${5:action}, :${6:action}]}}${7:, :except => ${8:[:${9:action}, :${10:action}]}}}"
 6 |   },
 7 |   "hide": {
 8 |     "prefix": "hide",
 9 |     "description": "page.hide (*ids)",
10 |     "body": "page.hide ${1:\"${2:id(s)}\"}"
11 |   },
12 |   "ins": {
13 |     "prefix": "ins",
14 |     "description": "page.insert_html (position, id, partial)",
15 |     "body": "page.insert_html :${1:top}, ${2:\"${3:id}\"}, :${4:partial => \"${5:template}\"}"
16 |   },
17 |   "rep": {
18 |     "prefix": "rep",
19 |     "description": "page.replace (id, partial)",
20 |     "body": "page.replace ${1:\"${2:id}\"}, :${3:partial => \"${4:template}\"}"
21 |   },
22 |   "reph": {
23 |     "prefix": "reph",
24 |     "description": "page.replace_html (id, partial)",
25 |     "body": "page.replace_html ${1:\"${2:id}\"}, :${3:partial => \"${4:template}\"}"
26 |   },
27 |   "show": {
28 |     "prefix": "show",
29 |     "description": "page.show (*ids)",
30 |     "body": "page.show ${1:\"${2:id(s)}\"}"
31 |   },
32 |   "tog": {
33 |     "prefix": "tog",
34 |     "description": "page.toggle (*ids)",
35 |     "body": "page.toggle ${1:\"${2:id(s)}\"}"
36 |   },
37 |   "vis": {
38 |     "prefix": "vis",
39 |     "description": "page.visual_effect (effect, id)",
40 |     "body": "page.visual_effect :${1:toggle_slide}, ${2:\"${3:DOM ID}\"}"
41 |   },
42 |   "rp": {
43 |     "prefix": "rp",
44 |     "description": "render (partial) (rp)",
45 |     "body": "render :partial => \"${1:item}\""
46 |   },
47 |   "rpc": {
48 |     "prefix": "rpc",
49 |     "description": "render (partial,collection) (rpc)",
50 |     "body": "render :partial => \"${1:item}\", :collection => ${2:@$1s}"
51 |   },
52 |   "rpl": {
53 |     "prefix": "rpl",
54 |     "description": "render (partial,locals) (rpl)",
55 |     "body": "render :partial => \"${1:item}\", :locals => { :${2:$1} => ${3:@$1}$0 \\}"
56 |   },
57 |   "rpo": {
58 |     "prefix": "rpo",
59 |     "description": "render (partial,object) (rpo)",
60 |     "body": "render :partial => \"${1:item}\", :object => ${2:@$1}"
61 |   },
62 |   "rps": {
63 |     "prefix": "rps",
64 |     "description": "render (partial,status) (rps)",
65 |     "body": "render :partial => \"${1:item}\", :status => ${2:500}"
66 |   },
67 |   "else": {
68 |     "prefix": "else",
69 |     "description": "else (ERB)",
70 |     "body": [
71 |       "<% else %>",
72 |       "\t$0"
73 |     ]
74 |   }
75 | }
76 | 


--------------------------------------------------------------------------------
/lua/user/code-action.lua:
--------------------------------------------------------------------------------
 1 | require("actions-preview").setup {
 2 |   -- options for vim.diff(): https://neovim.io/doc/user/lua.html#vim.diff()
 3 |   diff = {
 4 |     ctxlen = 3,
 5 |   },
 6 | 
 7 |   -- priority list of external command to highlight diff
 8 |   -- disabled by defalt, must be set by yourself
 9 |   highlight_command = {
10 |     -- require("actions-preview.highlight").delta(),
11 |     -- require("actions-preview.highlight").diff_so_fancy(),
12 |     -- require("actions-preview.highlight").diff_highlight(),
13 |   },
14 | 
15 |   -- priority list of preferred backend
16 |   backend = { "telescope", "nui" },
17 | 
18 |   -- options related to telescope.nvim
19 |   telescope = vim.tbl_extend(
20 |     "force",
21 |     -- telescope theme: https://github.com/nvim-telescope/telescope.nvim#themes
22 |     require("telescope.themes").get_dropdown(),
23 |     -- a table for customizing content
24 |     {
25 |       -- a function to make a table containing the values to be displayed.
26 |       -- fun(action: Action): { title: string, client_name: string|nil }
27 |       make_value = nil,
28 | 
29 |       -- a function to make a function to be used in `display` of a entry.
30 |       -- see also `:h telescope.make_entry` and `:h telescope.pickers.entry_display`.
31 |       -- fun(values: { index: integer, action: Action, title: string, client_name: string }[]): function
32 |       make_make_display = nil,
33 |     }
34 |   ),
35 | 
36 |   -- options for nui.nvim components
37 |   nui = {
38 |     -- component direction. "col" or "row"
39 |     dir = "col",
40 |     -- keymap for selection component: https://github.com/MunifTanjim/nui.nvim/tree/main/lua/nui/menu#keymap
41 |     keymap = nil,
42 |     -- options for nui Layout component: https://github.com/MunifTanjim/nui.nvim/tree/main/lua/nui/layout
43 |     layout = {
44 |       position = "50%",
45 |       size = {
46 |         width = "60%",
47 |         height = "90%",
48 |       },
49 |       min_width = 40,
50 |       min_height = 10,
51 |       relative = "editor",
52 |     },
53 |     -- options for preview area: https://github.com/MunifTanjim/nui.nvim/tree/main/lua/nui/popup
54 |     preview = {
55 |       size = "60%",
56 |       border = {
57 |         style = "rounded",
58 |         padding = { 0, 1 },
59 |       },
60 |     },
61 |     -- options for selection area: https://github.com/MunifTanjim/nui.nvim/tree/main/lua/nui/menu
62 |     select = {
63 |       size = "40%",
64 |       border = {
65 |         style = "rounded",
66 |         padding = { 0, 1 },
67 |       },
68 |     },
69 |   },
70 | }
71 | 


--------------------------------------------------------------------------------
/cool_snippets/ruby.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "#!": {
  3 |     "prefix": "#!",
  4 |     "description": "#!/usr/bin/env ruby",
  5 |     "body": [
  6 |       "#!/usr/bin/env ruby",
  7 |       "$0"
  8 |     ],
  9 |     "luasnip": {
 10 |       "priority": -50
 11 |     }
 12 |   },
 13 |   "defr": {
 14 |     "prefix": "defr",
 15 |     "description": "def <name> ... rescue ...",
 16 |     "body": [
 17 |       "def ${1:function_name}${2:(${3:*args})}",
 18 |       "\t$4",
 19 |       "rescue",
 20 |       "\t$0",
 21 |       "end"
 22 |     ]
 23 |   },
 24 |   "For": {
 25 |     "prefix": "For",
 26 |     "description": "(<from>..<to>).each { |<i>| <block> }",
 27 |     "body": "(${1:from}..${2:to}).each { |${3:i}| $0 \\}"
 28 |   },
 29 |   "until": {
 30 |     "prefix": "until",
 31 |     "description": "until <expression> ... end",
 32 |     "body": [
 33 |       "until ${1:expression}",
 34 |       "\t$0",
 35 |       "end"
 36 |     ]
 37 |   },
 38 |   "Until": {
 39 |     "prefix": "Until",
 40 |     "description": "begin ... end until <expression>",
 41 |     "body": [
 42 |       "begin",
 43 |       "\t$0",
 44 |       "end until ${1:expression}"
 45 |     ]
 46 |   },
 47 |   "while": {
 48 |     "prefix": "while",
 49 |     "description": "while <expression> ... end",
 50 |     "body": [
 51 |       "while ${1:expression}",
 52 |       "\t$0",
 53 |       "end"
 54 |     ]
 55 |   },
 56 |   "While": {
 57 |     "prefix": "While",
 58 |     "description": "begin ... end while <expression>",
 59 |     "body": [
 60 |       "begin",
 61 |       "\t$0",
 62 |       "end while ${1:expression}"
 63 |     ]
 64 |   },
 65 |   "begin": {
 66 |     "prefix": "begin",
 67 |     "description": "begin ... rescue ... end",
 68 |     "body": [
 69 |       "begin",
 70 |       "\t$1",
 71 |       "rescue",
 72 |       "\t$0",
 73 |       "end"
 74 |     ]
 75 |   },
 76 |   "rescue": {
 77 |     "prefix": "rescue",
 78 |     "body": [
 79 |       "rescue Exception => e",
 80 |       "\tputs e.message",
 81 |       "\tputs e.backtrace.inspect",
 82 |       "\t${0:# Rescue}"
 83 |     ]
 84 |   },
 85 |   "###": {
 86 |     "prefix": "###",
 87 |     "body": [
 88 |       "=begin",
 89 |       "\t$0",
 90 |       "=end"
 91 |     ]
 92 |   },
 93 |   "priv": {
 94 |     "prefix": "priv",
 95 |     "description": "private ",
 96 |     "body": [
 97 |       "private",
 98 |       "",
 99 |       "$0"
100 |     ]
101 |   },
102 |   "prot": {
103 |     "prefix": "prot",
104 |     "description": "protected",
105 |     "body": [
106 |       "protected",
107 |       "",
108 |       "$0"
109 |     ]
110 |   }
111 | }
112 | 


--------------------------------------------------------------------------------
/cool_snippets/mako.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "def": {
  3 |     "prefix": "def",
  4 |     "description": "definition",
  5 |     "body": [
  6 |       "<%def name=\"${1:name}\">",
  7 |       "\t${2:}",
  8 |       "</%def>"
  9 |     ],
 10 |     "luasnip": {
 11 |       "priority": -50
 12 |     }
 13 |   },
 14 |   "call": {
 15 |     "prefix": "call",
 16 |     "description": "call",
 17 |     "body": [
 18 |       "<%call expr=\"${1:name}\">",
 19 |       "\t${2:}",
 20 |       "</%call>"
 21 |     ]
 22 |   },
 23 |   "doc": {
 24 |     "prefix": "doc",
 25 |     "description": "doc",
 26 |     "body": [
 27 |       "<%doc>",
 28 |       "\t${1:}",
 29 |       "</%doc>"
 30 |     ]
 31 |   },
 32 |   "text": {
 33 |     "prefix": "text",
 34 |     "description": "text",
 35 |     "body": [
 36 |       "<%text>",
 37 |       "\t${1:}",
 38 |       "</%text>"
 39 |     ]
 40 |   },
 41 |   "for": {
 42 |     "prefix": "for",
 43 |     "description": "for",
 44 |     "body": [
 45 |       "% for ${1:i} in ${2:iter}:",
 46 |       "\t${3:}",
 47 |       "% endfor"
 48 |     ]
 49 |   },
 50 |   "if": {
 51 |     "prefix": "if",
 52 |     "description": "if/else",
 53 |     "body": [
 54 |       "% if ${1:condition}:",
 55 |       "\t${2:}",
 56 |       "% else:",
 57 |       "\t${3:}",
 58 |       "% endif"
 59 |     ]
 60 |   },
 61 |   "try": {
 62 |     "prefix": "try",
 63 |     "description": "try",
 64 |     "body": [
 65 |       "% try:",
 66 |       "\t${1:}",
 67 |       "% except${2:}:",
 68 |       "\t${3:pass}",
 69 |       "% endtry"
 70 |     ]
 71 |   },
 72 |   "wh": {
 73 |     "prefix": "wh",
 74 |     "description": "wh",
 75 |     "body": [
 76 |       "% while ${1:}:",
 77 |       "\t${2:}",
 78 |       "% endwhile"
 79 |     ]
 80 |   },
 81 |   "$": {
 82 |     "prefix": "$",
 83 |     "description": "$",
 84 |     "body": "\\${${1:}\\}"
 85 |   },
 86 |   "<%": {
 87 |     "prefix": "<%",
 88 |     "description": "<%",
 89 |     "body": "<% ${1:} %>"
 90 |   },
 91 |   "<!%": {
 92 |     "prefix": "<!%",
 93 |     "description": "<!%",
 94 |     "body": "<!% ${1:} %>"
 95 |   },
 96 |   "inherit": {
 97 |     "prefix": "inherit",
 98 |     "description": "inherit",
 99 |     "body": "<%inherit file=\"${1:filename}\" />"
100 |   },
101 |   "include": {
102 |     "prefix": "include",
103 |     "description": "include",
104 |     "body": "<%include file=\"${1:filename}\" />"
105 |   },
106 |   "namespace": {
107 |     "prefix": "namespace",
108 |     "description": "namespace",
109 |     "body": "<%namespace file=\"${1:name}\" />"
110 |   },
111 |   "page": {
112 |     "prefix": "page",
113 |     "description": "page",
114 |     "body": "<%page args=\"${1:}\" />"
115 |   }
116 | }
117 | 


--------------------------------------------------------------------------------
/lua/user/research.lua:
--------------------------------------------------------------------------------
  1 | local Menu = require "nui.menu"
  2 | local Input = require "nui.input"
  3 | local event = require("nui.utils.autocmd").event
  4 | 
  5 | local function trim(s)
  6 |   return (s:gsub("^%s*(.-)%s*$", "%1"))
  7 | end
  8 | local function callBrowser(value, browser)
  9 |   local cmdBrowser = "firefox"
 10 |   if browser == "Microsoft Edge" then
 11 |     cmdBrowser = "microsoft-edge-stable"
 12 |   end
 13 |   if browser == "Chromium" then
 14 |     cmdBrowser = "chromium"
 15 |   end
 16 |   if browser == "Google Chrome" then
 17 |     cmdBrowser = "google-chrome-stable"
 18 |   end
 19 |   if browser == "Firefox" then
 20 |     cmdBrowser = "firefox"
 21 |   end
 22 | 
 23 |   local command = string.format("silent! !%s 'https://google.com/search?q=%s'", cmdBrowser, value)
 24 |   vim.api.nvim_command(command)
 25 | end
 26 | 
 27 | local function BrowserInput(browser)
 28 |   local input = Input({
 29 |     position = "50%",
 30 |     size = {
 31 |       width = 50,
 32 |     },
 33 |     border = {
 34 |       style = "rounded",
 35 |       text = {
 36 |         top = "SEARCH",
 37 |         top_align = "center",
 38 |       },
 39 |     },
 40 |     win_options = {
 41 |       winhighlight = "Normal:Normal,FloatBorder:FloatBorder",
 42 |     },
 43 |   }, {
 44 |     prompt = " ",
 45 |     default_value = "how to ",
 46 |     on_close = function() end,
 47 |     on_submit = function(value)
 48 |       if trim(value) ~= "" then
 49 |         callBrowser(value, browser)
 50 |       end
 51 |     end,
 52 |   })
 53 | 
 54 |   input:mount()
 55 |   input:on(event.BufLeave, function()
 56 |     input:unmount()
 57 |   end)
 58 | end
 59 | local function MenuBrowser()
 60 |   local menu = Menu({
 61 |     position = "50%",
 62 |     size = {
 63 |       width = 20,
 64 |       height = 4,
 65 |     },
 66 |     border = {
 67 |       style = "rounded",
 68 |       text = {
 69 |         top = "BROWSER",
 70 |         top_align = "center",
 71 |       },
 72 |     },
 73 |     win_options = {
 74 |       winhighlight = "Normal:Normal,FloatBorder:FloatBorder",
 75 |     },
 76 |   }, {
 77 |     lines = {
 78 |       Menu.item "Firefox",
 79 |       Menu.item "Google Chrome",
 80 |       Menu.item "Chromium",
 81 |       Menu.item "Microsoft Edge",
 82 |     },
 83 |     max_width = 20,
 84 |     keymap = {
 85 |       focus_next = { "j", "<Down>", "<Tab>" },
 86 |       focus_prev = { "k", "<Up>", "<S-Tab>" },
 87 |       close = { "<Esc>", "<C-c>" },
 88 |       submit = { "<CR>", "<Space>" },
 89 |     },
 90 |     on_close = function() end,
 91 |     on_submit = function(item)
 92 |       BrowserInput(item.text)
 93 |     end,
 94 |   })
 95 | 
 96 |   menu:mount()
 97 | end
 98 | return {
 99 |   MenuBrowser = MenuBrowser,
100 | }
101 | 


--------------------------------------------------------------------------------
/cool_snippets/markdown.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "sec": {
  3 |     "prefix": "sec",
  4 |     "description": "Section",
  5 |     "body": [
  6 |       "# ${1:Section Name} #",
  7 |       "$0"
  8 |     ],
  9 |     "luasnip": {
 10 |       "priority": -50
 11 |     }
 12 |   },
 13 |   "ssec": {
 14 |     "prefix": "ssec",
 15 |     "description": "Sub Section",
 16 |     "body": [
 17 |       "## ${1:Section Name} ##",
 18 |       "$0"
 19 |     ]
 20 |   },
 21 |   "sssec": {
 22 |     "prefix": "sssec",
 23 |     "description": "SubSub Section",
 24 |     "body": [
 25 |       "### ${1:Section Name} ###",
 26 |       "$0"
 27 |     ]
 28 |   },
 29 |   "par": {
 30 |     "prefix": "par",
 31 |     "description": "Paragraph",
 32 |     "body": [
 33 |       "#### ${1:Paragraph Name} ####",
 34 |       "$0"
 35 |     ]
 36 |   },
 37 |   "spar": {
 38 |     "prefix": "spar",
 39 |     "description": "Paragraph",
 40 |     "body": [
 41 |       "##### ${1:Paragraph Name} #####",
 42 |       "$0"
 43 |     ]
 44 |   },
 45 |   "*": {
 46 |     "prefix": "*",
 47 |     "description": "italics",
 48 |     "body": "*${1:$TM_SELECTED_TEXT}*$0"
 49 |   },
 50 |   "**": {
 51 |     "prefix": "**",
 52 |     "description": "bold",
 53 |     "body": "**${1:$TM_SELECTED_TEXT}**$0"
 54 |   },
 55 |   "***": {
 56 |     "prefix": "***",
 57 |     "description": "bold italics",
 58 |     "body": "***${1:$TM_SELECTED_TEXT}***$0"
 59 |   },
 60 |   "/*": {
 61 |     "prefix": "/*",
 62 |     "description": "Comment",
 63 |     "body": "<!-- ${1:$TM_SELECTED_TEXT} -->$0"
 64 |   },
 65 |   "link": {
 66 |     "prefix": "link",
 67 |     "description": "Link to something",
 68 |     "body": "[${1:${TM_SELECTED_TEXT:Text}}](${3:https://${2:www.url.com}})$0"
 69 |   },
 70 |   "ilc": {
 71 |     "prefix": "ilc",
 72 |     "description": "Inline Code",
 73 |     "body": "`${1:$TM_SELECTED_TEXT}`$0"
 74 |   },
 75 |   "cbl": {
 76 |     "prefix": "cbl",
 77 |     "description": "Codeblock",
 78 |     "body": [
 79 |       "```$1",
 80 |       "${2:$TM_SELECTED_TEXT}",
 81 |       "```",
 82 |       "$0"
 83 |     ]
 84 |   },
 85 |   "refl": {
 86 |     "prefix": "refl",
 87 |     "description": "Reference Link",
 88 |     "body": [
 89 |       "[${1:${TM_SELECTED_TEXT:Text}}][${2:id}]$0",
 90 |       "",
 91 |       "[$2]:${4:https://${3:www.url.com}} \"${5:$4}\""
 92 |     ]
 93 |   },
 94 |   "fnt": {
 95 |     "prefix": "fnt",
 96 |     "description": "Footnote",
 97 |     "body": [
 98 |       "[^${1:${TM_SELECTED_TEXT:Footnote}}]$0",
 99 |       "",
100 |       "[^$1]:${2:Text}"
101 |     ]
102 |   },
103 |   "detail": {
104 |     "prefix": "detail",
105 |     "description": "Disclosure",
106 |     "body": [
107 |       "<details${3: open=\"\"}>",
108 |       "  ${1:<summary>$2</summary>}$0",
109 |       "</details>"
110 |     ]
111 |   }
112 | }
113 | 


--------------------------------------------------------------------------------
/cool_snippets/php.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "pub": {
  3 |     "prefix": "pub",
  4 |     "description": "Public function",
  5 |     "body": [
  6 |       "/**",
  7 |       " * ${3:undocumented function}",
  8 |       " *",
  9 |       " * @return ${4:void}",
 10 |       " */",
 11 |       "public function ${1:name}(${2:\\$param})",
 12 |       "{",
 13 |       "\t$TM_SELECTED_TEXT${5:return null;}",
 14 |       "\\}",
 15 |       "$0"
 16 |     ]
 17 |   },
 18 |   "pro": {
 19 |     "prefix": "pro",
 20 |     "description": "Protected function",
 21 |     "body": [
 22 |       "/**",
 23 |       " * ${3:undocumented function}",
 24 |       " *",
 25 |       " * @return ${4:void}",
 26 |       " */",
 27 |       "protected function ${1:name}(${2:\\$param})",
 28 |       "{",
 29 |       "\t$TM_SELECTED_TEXT${5:return null;}",
 30 |       "\\}",
 31 |       "$0"
 32 |     ]
 33 |   },
 34 |   "pri": {
 35 |     "prefix": "pri",
 36 |     "description": "Private function",
 37 |     "body": [
 38 |       "/**",
 39 |       " * ${3:undocumented function}",
 40 |       " *",
 41 |       " * @return ${4:void}",
 42 |       " */",
 43 |       "private function ${1:name}(${2:\\$param})",
 44 |       "{",
 45 |       "\t$TM_SELECTED_TEXT${5:return null;}",
 46 |       "\\}",
 47 |       "$0"
 48 |     ]
 49 |   },
 50 |   "pubs": {
 51 |     "prefix": "pubs",
 52 |     "description": "Public static function",
 53 |     "body": [
 54 |       "/**",
 55 |       " * ${3:undocumented function}",
 56 |       " *",
 57 |       " * @return ${4:void}",
 58 |       " */",
 59 |       "public static function ${1:name}(${2:\\$param})",
 60 |       "{",
 61 |       "\t$TM_SELECTED_TEXT${5:return null;}",
 62 |       "\\}",
 63 |       "$0"
 64 |     ]
 65 |   },
 66 |   "pros": {
 67 |     "prefix": "pros",
 68 |     "description": "Protected static function",
 69 |     "body": [
 70 |       "/**",
 71 |       " * ${3:undocumented function}",
 72 |       " *",
 73 |       " * @return ${4:void}",
 74 |       " */",
 75 |       "protected static function ${1:name}(${2:\\$param})",
 76 |       "{",
 77 |       "\t$TM_SELECTED_TEXT${5:return null;}",
 78 |       "\\}",
 79 |       "$0"
 80 |     ]
 81 |   },
 82 |   "pris": {
 83 |     "prefix": "pris",
 84 |     "description": "Private static function",
 85 |     "body": [
 86 |       "/**",
 87 |       " * ${3:undocumented function}",
 88 |       " *",
 89 |       " * @return ${4:void}",
 90 |       " */",
 91 |       "private static function ${1:name}(${2:\\$param})",
 92 |       "{",
 93 |       "\t$TM_SELECTED_TEXT${5:return null;}",
 94 |       "\\}",
 95 |       "$0"
 96 |     ]
 97 |   },
 98 |   "fu": {
 99 |     "prefix": "fu",
100 |     "description": "Function snip",
101 |     "body": [
102 |       "function ${1:name}(${2:\\$param})",
103 |       "{",
104 |       "\t$TM_SELECTED_TEXT${3:return null;}",
105 |       "\\}",
106 |       "$0"
107 |     ]
108 |   }
109 | }
110 | 


--------------------------------------------------------------------------------
/cool_snippets/lua.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "#!": {
  3 |     "prefix": "#!",
  4 |     "description": "#!/usr/bin/env lua",
  5 |     "body": [
  6 |       "#!/usr/bin/env lua",
  7 |       "$0"
  8 |     ],
  9 |     "luasnip": {
 10 |       "priority": -50
 11 |     }
 12 |   },
 13 |   "forp": {
 14 |     "prefix": "forp",
 15 |     "description": "pair for loop",
 16 |     "body": [
 17 |       "for ${1:name},${2:val} in pairs(${3:table_name}) do",
 18 |       "\t$0",
 19 |       "end"
 20 |     ]
 21 |   },
 22 |   "fori": {
 23 |     "prefix": "fori",
 24 |     "description": "ipair for foop",
 25 |     "body": [
 26 |       "for ${1:idx},${2:val} in ipairs(${3:table_name}) do",
 27 |       "\t$0",
 28 |       "end"
 29 |     ]
 30 |   },
 31 |   "do": {
 32 |     "prefix": "do",
 33 |     "description": "do block",
 34 |     "body": [
 35 |       "do",
 36 |       "\t$0",
 37 |       "end"
 38 |     ]
 39 |   },
 40 |   "repeat": {
 41 |     "prefix": "repeat",
 42 |     "description": "repeat loop",
 43 |     "body": [
 44 |       "repeat",
 45 |       "\t$1",
 46 |       "until $0"
 47 |     ]
 48 |   },
 49 |   "while": {
 50 |     "prefix": "while",
 51 |     "description": "while loop",
 52 |     "body": [
 53 |       "while $1 do",
 54 |       "\t$0",
 55 |       "end"
 56 |     ]
 57 |   },
 58 |   "if": {
 59 |     "prefix": "if",
 60 |     "description": "if statement",
 61 |     "body": [
 62 |       "if $1 then",
 63 |       "\t$0",
 64 |       "end"
 65 |     ]
 66 |   },
 67 |   "ife": {
 68 |     "prefix": "ife",
 69 |     "description": "if/else statement",
 70 |     "body": [
 71 |       "if $1 then",
 72 |       "\t$2",
 73 |       "else",
 74 |       "\t$0",
 75 |       "end"
 76 |     ]
 77 |   },
 78 |   "eif": {
 79 |     "prefix": "eif",
 80 |     "description": "if/elseif statement",
 81 |     "body": [
 82 |       "if $1 then",
 83 |       "\t$2",
 84 |       "elseif $3 then",
 85 |       "\t$0",
 86 |       "end"
 87 |     ]
 88 |   },
 89 |   "eife": {
 90 |     "prefix": "eife",
 91 |     "description": "if/elseif/else statement",
 92 |     "body": [
 93 |       "if $1 then",
 94 |       "\t$2",
 95 |       "elseif $3 then",
 96 |       "\t$4",
 97 |       "else",
 98 |       "\t$0",
 99 |       "end"
100 |     ]
101 |   },
102 |   "pcall": {
103 |     "prefix": "pcall",
104 |     "description": "pcall statement",
105 |     "body": [
106 |       "local ok, err = pcall(${1:your_function})",
107 |       "if not ok then",
108 |       "\thandler(${2:ok, err})",
109 |       "${3:else",
110 |       "\tsuccess(${4:ok, err})",
111 |       "}end"
112 |     ]
113 |   },
114 |   "local": {
115 |     "prefix": "local",
116 |     "description": "local x = 1",
117 |     "body": "local ${1:x} = ${0:1}"
118 |   },
119 |   "use": {
120 |     "prefix": "use",
121 |     "description": "Use",
122 |     "body": "use { '$1' \\}"
123 |   },
124 |   "req": {
125 |     "prefix": "req",
126 |     "description": "Require",
127 |     "body": "require('$1')"
128 |   }
129 | }
130 | 


--------------------------------------------------------------------------------
/lua/user/trouble.lua:
--------------------------------------------------------------------------------
 1 | -- local present, trouble = pcall(require, "trouble")
 2 | --
 3 | -- if not present then
 4 | --   return
 5 | -- end
 6 | --
 7 | -- trouble.setup {
 8 | --   position = "bottom", -- position of the list can be: bottom, top, left, right
 9 | --  
10 | --
11 | --   height = 10, -- height of the trouble list when position is top or bottom
12 | --   width = 50, -- width of the list when position is left or right
13 | --   icons = true, -- use devicons for filenames
14 | --   mode = "workspace_diagnostics", -- "workspace_diagnostics", "document_diagnostics", "quickfix", "lsp_references", "loclist"
15 | --   fold_open = "", -- icon used for open folds
16 | --   fold_closed = "", -- icon used for closed folds
17 | --   group = true, -- group results by file
18 | --   padding = true, -- add an extra new line on top of the list
19 | --   action_keys = { -- key mappings for actions in the trouble list
20 | --     -- map to {} to remove a mapping, for example:
21 | --     -- close = {},
22 | --     close = "q", -- close the list
23 | --     cancel = "<esc>", -- cancel the preview and get back to your last window / buffer / cursor
24 | --     refresh = "r", -- manually refresh
25 | --     jump = { "<cr>", "<tab>" }, -- jump to the diagnostic or open / close folds
26 | --     open_split = { "<c-x>" }, -- open buffer in new split
27 | --     open_vsplit = { "<c-v>" }, -- open buffer in new vsplit
28 | --     open_tab = { "<c-t>" }, -- open buffer in new tab
29 | --     jump_close = { "o" }, -- jump to the diagnostic and close the list
30 | --     toggle_mode = "m", -- toggle between "workspace" and "document" diagnostics mode
31 | --     toggle_preview = "P", -- toggle auto_preview
32 | --     hover = "K", -- opens a small popup with the full multiline message
33 | --     preview = "p", -- preview the diagnostic location
34 | --     close_folds = { "zM", "zm" }, -- close all folds
35 | --     open_folds = { "zR", "zr" }, -- open all folds
36 | --     toggle_fold = { "zA", "za" }, -- toggle fold of current file
37 | --     previous = "k", -- preview item
38 | --     next = "j", -- next item
39 | --   },
40 | --   indent_lines = true, -- add an indent guide below the fold icons
41 | --   auto_open = false, -- automatically open the list when you have diagnostics
42 | --   auto_close = false, -- automatically close the list when you have no diagnostics
43 | --   auto_preview = true, -- automatically preview the location of the diagnostic. <esc> to close preview and go back to last window
44 | --   auto_fold = false, -- automatically fold a file trouble list at creation
45 | --   auto_jump = { "lsp_definitions" }, -- for the given modes, automatically jump if there is only a single result
46 | --   signs = {
47 | --     -- icons / text used for a diagnostic
48 | --     error = "",
49 | --     warning = "",
50 | --     hint = "",
51 | --     information = "",
52 | --     other = "﫠",
53 | --   },
54 | --   use_diagnostic_signs = false, -- enabling this will use the signs defined in your lsp client
55 | -- }
56 | 


--------------------------------------------------------------------------------
/lua/user/treesitter.lua:
--------------------------------------------------------------------------------
 1 | -- local status_ok, configs = pcall(require, "nvim-treesitter.configs")
 2 | -- if not status_ok then
 3 | --   return
 4 | -- end
 5 | -- configs.setup({
 6 | --   ensure_installed = { "c", "cpp", "lua", "javascript", "typescript", "python", "bash", "cmake", "json5", "gitignore",
 7 | --     "css", "tsx", "json", "vim", "dockerfile", "html", "css", "yaml", "markdown", "sql" },
 8 | --   -- ensure_installed = "all", -- one of "all" or a list of languages
 9 | --   ignore_install = { "" }, -- List of parsers to ignore installing
10 | --   sync_install = false, -- install languages synchronously (only applied to `ensure_installed`)
11 | --   highlight = {
12 | --     enable = true, -- false will disable the whole extension
13 | --     disable = { "css" }, -- list of language that will be disabled
14 | --     additional_vim_highlighting = false,
15 | --   },
16 | --   autopairs = {
17 | --     enable = true,
18 | --   },
19 | --   indent = { enable = true, disable = { "python", "css" } },
20 | --
21 | --   context_commentstring = {
22 | --     enable = true,
23 | --     enable_autocmd = false,
24 | --   },
25 | --   rainbow = {
26 | --     enable = true,
27 | --     -- disable = { "jsx", "cpp" }, list of languages you want to disable the plugin for
28 | --     extended_mode = true, -- Also highlight non-bracket delimiters like html tags, boolean or table: lang -> boolean
29 | --     max_file_lines = nil, -- Do not enable for files with more than n lines, int
30 | --     -- colors = {}, -- table of hex strings
31 | --     -- termcolors = {} -- table of colour name strings
32 | --   },
33 | --   autotag = {
34 | --     enable = true,
35 | --   }
36 | -- })
37 | --
38 | --
39 | 
40 | local present, treesitter = pcall(require, "nvim-treesitter.configs")
41 | 
42 | if not present then
43 |   return
44 | end
45 | 
46 | local options = {
47 |   ensure_installed = {
48 |     "c",
49 |     "cpp",
50 |     "lua",
51 |     "javascript",
52 |     "typescript",
53 |     "python",
54 |     "bash",
55 |     "cmake",
56 |     "json5",
57 |     "gitignore",
58 |     "java",
59 |     "go",
60 |     "css",
61 |     "vue",
62 |     "tsx",
63 |     "json",
64 |     "vim",
65 |     "dockerfile",
66 |     "html",
67 |     "css",
68 |     "yaml",
69 |     "markdown",
70 |     "sql",
71 |   },
72 | 
73 |   context_commentstring = {
74 |     enable = true,
75 |     enable_autocmd = false,
76 |   },
77 |   rainbow = {
78 |     enable = true,
79 |     -- disable = { "jsx", "cpp" }, list of languages you want to disable the plugin for
80 |     extended_mode = true, -- Also highlight non-bracket delimiters like html tags, boolean or table: lang -> boolean
81 |     max_file_lines = nil, -- Do not enable for files with more than n lines, int
82 |     -- colors = {}, -- table of hex strings
83 |     -- termcolors = {} -- table of colour name strings
84 |   },
85 |   highlight = {
86 |     enable = true,
87 |     use_languagetree = true,
88 |   },
89 | 
90 |   indent = {
91 |     enable = true,
92 |   },
93 | }
94 | 
95 | treesitter.setup(options)
96 | 


--------------------------------------------------------------------------------
/lua/user/luasnip_setup.lua:
--------------------------------------------------------------------------------
  1 | local present, luasnip = pcall(require, "luasnip")
  2 | if not present then
  3 | 	return
  4 | end
  5 | 
  6 | local ls = require("luasnip")
  7 | local s = ls.snippet
  8 | local fmt = require("luasnip.extras.fmt").fmt
  9 | local rep = require("luasnip.extras").rep
 10 | local sn = ls.snippet_node
 11 | local isn = ls.indent_snippet_node
 12 | local t = ls.text_node
 13 | local i = ls.insert_node
 14 | local f = ls.function_node
 15 | local c = ls.choice_node
 16 | local d = ls.dynamic_node
 17 | local r = ls.restore_node
 18 | 
 19 | require("luasnip.loaders.from_lua").load({ paths = "~/.config/nvim/my-snippets/" })
 20 | 
 21 | local options = {
 22 | 	history = true,
 23 | 	enable_autosnippets = true,
 24 | 	ext_opts = {
 25 | 		[c] = {
 26 | 			active = {
 27 | 				virt_text = { { "●", "GruvboxOrange" } },
 28 | 			},
 29 | 		},
 30 | 	},
 31 | 	updateevents = "TextChanged,TextChangedI",
 32 | }
 33 | 
 34 | luasnip.config.set_config(options)
 35 | -- require("luasnip.loaders.from_vscode").lazy_load()
 36 | require("luasnip.loaders.from_vscode").lazy_load({ paths = "./cool_snippets" })
 37 | 
 38 | vim.api.nvim_create_autocmd("InsertLeave", {
 39 | 	callback = function()
 40 | 		if
 41 | 			require("luasnip").session.current_nodes[vim.api.nvim_get_current_buf()]
 42 | 			and not require("luasnip").session.jump_active
 43 | 		then
 44 | 			require("luasnip").unlink_current()
 45 | 		end
 46 | 	end,
 47 | })
 48 | 
 49 | ls.add_snippets("typescript", {
 50 | 	s(
 51 | 		"cfun",
 52 | 		fmt(
 53 | 			"const {} = ({}) => {{\n console.log('\\nEntering {}')\n {}\n console.log('Leaving {}\\n')\n}}",
 54 | 			{ i(1, "functionName"), i(2), rep(1), i(3), rep(1) }
 55 | 		)
 56 | 	),
 57 | 	s(
 58 | 		"expfun",
 59 | 		fmt(
 60 | 			"export const {} = ({}) => {{\n console.log('\\nEntering {}')\n {}\n console.log('Leaving {}\\n')\n}}",
 61 | 			{ i(1, "functionName"), i(2), rep(1), i(3), rep(1) }
 62 | 		)
 63 | 	),
 64 | 	s("funLogE", fmt("console.log('\\nEntering {}')\n", { i(1) })),
 65 | 	s("funLogL", fmt("console.log('Leaving {}\\n')\n", { i(1) })),
 66 | 
 67 | 	-- s(
 68 | 	-- 	"cfun",
 69 | 	-- 	{
 70 | 	-- 		t("const "),
 71 | 	-- 		i(1),
 72 | 	-- 		t(" = () => { console.log('Entering ', "),
 73 | 	-- 		rep(1),
 74 | 	-- 		t(")"),
 75 | 	-- 		i(2),
 76 | 	-- 		t(" console.log('Leaving ', "),
 77 | 	-- 		rep(1),
 78 | 	-- 		t(")"),
 79 | 	-- 		i(3),
 80 | 	-- 		t("}"),
 81 | 	-- 	},
 82 | 	-- 	{}
 83 | 	-- ),
 84 | })
 85 | 
 86 | -- Shorten function name
 87 | local keymap = vim.keymap.set
 88 | -- lua snip Keymaps
 89 | keymap({ "i", "s" }, "<C-k>", function()
 90 | 	if ls.expand_or_jumpable() then
 91 | 		ls.expand_or_jump()
 92 | 	end
 93 | end, { silent = true })
 94 | 
 95 | keymap({ "i", "s" }, "<C-j>", function()
 96 | 	if ls.jumpable(-1) then
 97 | 		ls.jump(-1)
 98 | 	end
 99 | end, { silent = true })
100 | 
101 | keymap("i", "<C-l>", function()
102 | 	if ls.choice_active() then
103 | 		ls.change_choice(1)
104 | 	end
105 | end, { silent = true })
106 | 
107 | keymap("n", "<leader><leader>s", "<cmd>source ~/.config/nvim/lua/user/luasnip_setup.lua<CR>")
108 | 


--------------------------------------------------------------------------------
/cool_snippets/gitcommit.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "fix": {
  3 |     "prefix": "fix",
  4 |     "description": "fix conventional commit",
  5 |     "body": [
  6 |       "fix(${1:scope}): ${2:title}",
  7 |       "",
  8 |       "${0:$TM_SELECTED_TEXT}"
  9 |     ]
 10 |   },
 11 |   "feat": {
 12 |     "prefix": "feat",
 13 |     "description": "feat conventional commit",
 14 |     "body": [
 15 |       "feat(${1:scope}): ${2:title}",
 16 |       "",
 17 |       "${0:$TM_SELECTED_TEXT}"
 18 |     ]
 19 |   },
 20 |   "chore": {
 21 |     "prefix": "chore",
 22 |     "description": "chore conventional commit",
 23 |     "body": [
 24 |       "chore(${1:scope}): ${2:title}",
 25 |       "",
 26 |       "${0:$TM_SELECTED_TEXT}"
 27 |     ]
 28 |   },
 29 |   "docs": {
 30 |     "prefix": "docs",
 31 |     "description": "docs conventional commit",
 32 |     "body": [
 33 |       "docs(${1:scope}): ${2:title}",
 34 |       "",
 35 |       "${0:$TM_SELECTED_TEXT}"
 36 |     ]
 37 |   },
 38 |   "improvement": {
 39 |     "prefix": "improvement",
 40 |     "description": "improvement conventional commit",
 41 |     "body": [
 42 |       "improvement(${1:scope}): ${2:title}",
 43 |       "",
 44 |       "${0:$TM_SELECTED_TEXT}"
 45 |     ]
 46 |   },
 47 |   "perf": {
 48 |     "prefix": "perf",
 49 |     "description": "perf conventional commit",
 50 |     "body": [
 51 |       "perf(${1:scope}): ${2:title}",
 52 |       "",
 53 |       "${0:$TM_SELECTED_TEXT}"
 54 |     ]
 55 |   },
 56 |   "refactor": {
 57 |     "prefix": "refactor",
 58 |     "description": "refactor conventional commit",
 59 |     "body": [
 60 |       "refactor(${1:scope}): ${2:title}",
 61 |       "",
 62 |       "${0:$TM_SELECTED_TEXT}"
 63 |     ]
 64 |   },
 65 |   "test": {
 66 |     "prefix": "test",
 67 |     "description": "test conventional commit",
 68 |     "body": [
 69 |       "test(${1:scope}): ${2:title}",
 70 |       "",
 71 |       "${0:$TM_SELECTED_TEXT}"
 72 |     ]
 73 |   },
 74 |   "ci": {
 75 |     "prefix": "ci",
 76 |     "description": "ci conventional commit",
 77 |     "body": [
 78 |       "ci(${1:scope}): ${2:title}",
 79 |       "",
 80 |       "${0:$TM_SELECTED_TEXT}"
 81 |     ]
 82 |   },
 83 |   "build": {
 84 |     "prefix": "build",
 85 |     "description": "build conventional commit",
 86 |     "body": [
 87 |       "build(${1:scope}): ${2:title}",
 88 |       "",
 89 |       "${0:$TM_SELECTED_TEXT}"
 90 |     ]
 91 |   },
 92 |   "sign": {
 93 |     "prefix": "sign",
 94 |     "description": "Signature",
 95 |     "body": [
 96 |       "-------------------------------------------------------------------------------",
 97 |       "${1:Company Name}",
 98 |       "",
 99 |       "${2:Author Name}",
100 |       "",
101 |       "${3:Streetname 21}",
102 |       "${4:City and Area}",
103 |       "",
104 |       "${5:Tel: \t\t\t\t\t\t+44 (0)987 / 888 8888}",
105 |       "${6:Fax: \t\t\t\t\t\t+44 (0)987 / 888 8882}",
106 |       "${7:Mail: \t\t\t\t\tEmail}",
107 |       "${8:Web: \t\t\t\t\t\thttps://}",
108 |       "-------------------------------------------------------------------------------",
109 |       "$0"
110 |     ]
111 |   }
112 | }
113 | 


--------------------------------------------------------------------------------
/lua/user/todo-comments.lua:
--------------------------------------------------------------------------------
 1 | local present, todo = pcall(require, "todo-comments")
 2 | 
 3 | if not present then
 4 |   return
 5 | end
 6 | 
 7 | local icons = require("user.icons")
 8 | 
 9 | todo.setup {
10 |   signs = true, -- show icons in the signs column
11 |   sign_priority = 8, -- sign priority
12 |   -- keywords recognized as todo comments
13 |   keywords = {
14 |     FIX = {
15 |       icon = " ", -- icon used for the sign, and in search results
16 |       color = "error", -- can be a hex color, or a named color (see below)
17 |       alt = { "FIXME", "BUG", "FIXIT", "ISSUE" }, -- a set of other keywords that all map to this FIX keywords
18 |       -- signs = false, -- configure signs for some keywords individually
19 |     },
20 |     -- TODO = { icon = " ", color = "info" },
21 |     -- HACK = { icon = " ", color = "warning" },
22 |     -- WARN = { icon = " ", color = "warning", alt = { "WARNING", "XXX" } },
23 |     -- PERF = { icon = " ", alt = { "OPTIM", "PERFORMANCE", "OPTIMIZE" } },
24 |     -- NOTE = { icon = " ", color = "hint", alt = { "INFO" } },
25 |     TODO = { icon = icons.ui.Check, color = "info" },
26 |     HACK = { icon = icons.ui.Fire, color = "warning" },
27 |     WARN = { icon = icons.diagnostics.Warning, color = "warning", alt = { "WARNING", "XXX" } },
28 |     PERF = { icon = icons.diagnostics.Information, alt = { "OPTIM", "PERFORMANCE", "OPTIMIZE" } },
29 |     NOTE = { icon = icons.diagnostics.Hint, color = "hint", alt = { "INFO" } },
30 |   },
31 |   merge_keywords = true, -- when true, custom keywords will be merged with the defaults
32 |   -- highlighting of the line containing the todo comment
33 |   -- * before: highlights before the keyword (typically comment characters)
34 |   -- * keyword: highlights of the keyword
35 |   -- * after: highlights after the keyword (todo text)
36 |   highlight = {
37 |     before = "", -- "fg" or "bg" or empty
38 |     keyword = "wide", -- "fg", "bg", "wide" or empty. (wide is the same as bg, but will also highlight surrounding characters)
39 |     after = "fg", -- "fg" or "bg" or empty
40 |     pattern = [[.*<(KEYWORDS)\s*:]], -- pattern or table of patterns, used for highlightng (vim regex)
41 |     comments_only = true, -- uses treesitter to match keywords in comments only
42 |     max_line_len = 400, -- ignore lines longer than this
43 |     exclude = {}, -- list of file types to exclude highlighting
44 |   },
45 |   -- list of named colors where we try to extract the guifg from the
46 |   -- list of hilight groups or use the hex color if hl not found as a fallback
47 |   colors = {
48 |     error = { "DiagnosticError", "ErrorMsg", "#DC2626" },
49 |     warning = { "DiagnosticWarning", "WarningMsg", "#FBBF24" },
50 |     info = { "DiagnosticInfo", "#2563EB" },
51 |     hint = { "DiagnosticHint", "#10B981" },
52 |     default = { "Identifier", "#7C3AED" },
53 |   },
54 |   search = {
55 |     command = "rg",
56 |     args = {
57 |       "--color=never",
58 |       "--no-heading",
59 |       "--with-filename",
60 |       "--line-number",
61 |       "--column",
62 |     },
63 |     -- regex that will be used to match keywords.
64 |     -- don't replace the (KEYWORDS) placeholder
65 |     pattern = [[\b(KEYWORDS):]], -- ripgrep regex
66 |     -- pattern = [[\b(KEYWORDS)\b]], -- match without the extra colon. You'll likely get false positives
67 |   },
68 | }
69 | 


--------------------------------------------------------------------------------
/cool_snippets/php-symfony2.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "sfa": {
 3 |     "prefix": "sfa",
 4 |     "description": "Symfony 2 Controller action",
 5 |     "body": [
 6 |       "/**",
 7 |       "* @Route(\"/${1:route_name}\", name=\"$1\")",
 8 |       "* @Template()",
 9 |       "*/",
10 |       "public function $1Action($2)",
11 |       "{",
12 |       "\t$3",
13 |       "\treturn ${4:[];}$0",
14 |       "\\}"
15 |     ]
16 |   },
17 |   "act": {
18 |     "prefix": "act",
19 |     "description": "Symfony2 action",
20 |     "body": [
21 |       "/**",
22 |       " * @Route(\"$3\", name=\"$4\")",
23 |       " * @Method({${5:\"POST\"}\\})",
24 |       " * @Template()",
25 |       " */",
26 |       "public function $1Action($2)",
27 |       "{",
28 |       "\t$6",
29 |       "\\}"
30 |     ]
31 |   },
32 |   "redir": {
33 |     "prefix": "redir",
34 |     "description": "Symfony2 redirect",
35 |     "body": "\\$this->redirect(\\$this->generateUrl('$1', $2));"
36 |   },
37 |   "usecontroller": {
38 |     "prefix": "usecontroller",
39 |     "description": "Symfony2 use Symfony\\..\\Controller",
40 |     "body": "use Symfony\\Bundle\\FrameworkBundle\\Controller\\Controller;$1"
41 |   },
42 |   "usereauest": {
43 |     "prefix": "usereauest",
44 |     "description": "Symfony2 use Symfony\\..\\Request",
45 |     "body": "use Symfony\\Component\\HttpFoundation\\Request;$1"
46 |   },
47 |   "useroute": {
48 |     "prefix": "useroute",
49 |     "description": "Symfony2 use Sensio\\..\\Route",
50 |     "body": "use Sensio\\Bundle\\FrameworkExtraBundle\\Configuration\\Route;$1"
51 |   },
52 |   "useresponse": {
53 |     "prefix": "useresponse",
54 |     "description": "Symfony2 use Symfony\\..\\Response",
55 |     "body": "use Symfony\\Component\\HttpFoundation\\Response;$1"
56 |   },
57 |   "usefile": {
58 |     "prefix": "usefile",
59 |     "description": "Symfony2 use Symfony\\..\\File",
60 |     "body": "use Symfony\\Component\\HttpFoundation\\File\\UploadedFile;$1"
61 |   },
62 |   "useassert": {
63 |     "prefix": "useassert",
64 |     "description": "Symfony2 use Symfony\\..\\Constraints as Assert",
65 |     "body": "use Symfony\\Component\\Validator\\Constraints as Assert;$1"
66 |   },
67 |   "usetemplate": {
68 |     "prefix": "usetemplate",
69 |     "description": "Symfony2 use Sensio\\..\\Template",
70 |     "body": "use Sensio\\Bundle\\FrameworkExtraBundle\\Configuration\\Template;$1"
71 |   },
72 |   "usecache": {
73 |     "prefix": "usecache",
74 |     "description": "Symfony2 use Sensio\\..\\Cache",
75 |     "body": "use Sensio\\Bundle\\FrameworkExtraBundle\\Configuration\\Cache;$1"
76 |   },
77 |   "usemethod": {
78 |     "prefix": "usemethod",
79 |     "description": "Symfony2 use Sensio\\..\\Method",
80 |     "body": "use Sensio\\Bundle\\FrameworkExtraBundle\\Configuration\\Method;$1"
81 |   },
82 |   "usearray": {
83 |     "prefix": "usearray",
84 |     "description": "Symfony2 use Doctrine\\..\\ArrayCollection",
85 |     "body": "use Doctrine\\Common\\Collections\\ArrayCollection;$1"
86 |   },
87 |   "useorm": {
88 |     "prefix": "useorm",
89 |     "description": "Symfony2 use Doctrine\\..\\Mapping as ORM",
90 |     "body": "use Doctrine\\ORM\\Mapping as ORM;$1"
91 |   },
92 |   "usesecure": {
93 |     "prefix": "usesecure",
94 |     "description": "Symfony2 use JMS\\..\\Secure",
95 |     "body": "use JMS\\SecurityExtraBundle\\Annotation\\Secure;$1"
96 |   }
97 | }
98 | 


--------------------------------------------------------------------------------
/cool_snippets/coffee-react.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "createClass": {
  3 |     "prefix": "createClass",
  4 |     "description": "React define Class",
  5 |     "body": [
  6 |       "${1:classname}Class = React.createClass",
  7 |       "\tdisplayName: \"$1\"",
  8 |       "\trender: ->",
  9 |       "\t\t$2",
 10 |       "$1 = React.createFactory($1)"
 11 |     ],
 12 |     "luasnip": {
 13 |       "priority": -49
 14 |     }
 15 |   },
 16 |   "PropTypes": {
 17 |     "prefix": "PropTypes",
 18 |     "description": "React define propTypes",
 19 |     "body": [
 20 |       "propTypes: ->",
 21 |       "\t${1:myVar}: React.PropTypes.${2:type}${3:.isRequired}"
 22 |     ]
 23 |   },
 24 |   "propType": {
 25 |     "prefix": "propType",
 26 |     "description": "React propType (key/value)",
 27 |     "body": [
 28 |       "${1:myVar}: React.PropTypes.${2:type}${3:.isRequired}",
 29 |       "$4"
 30 |     ]
 31 |   },
 32 |   "setState": {
 33 |     "prefix": "setState",
 34 |     "description": "React setState",
 35 |     "body": [
 36 |       "@setState",
 37 |       "\t${1:myvar}: ${2:myvalue}",
 38 |       "\t$3"
 39 |     ]
 40 |   },
 41 |   "getInitialState": {
 42 |     "prefix": "getInitialState",
 43 |     "description": "React define getInitialState",
 44 |     "body": [
 45 |       "getInitialState: ->",
 46 |       "\t${1:myvar}: ${2:myvalue}",
 47 |       "\t$3"
 48 |     ]
 49 |   },
 50 |   "getDefaultProps": {
 51 |     "prefix": "getDefaultProps",
 52 |     "description": "React define getDefaultProps",
 53 |     "body": [
 54 |       "getDefaultProps: ->",
 55 |       "\t${1:myvar}: ${2:myvalue}",
 56 |       "\t$3"
 57 |     ]
 58 |   },
 59 |   "componentWillMount": {
 60 |     "prefix": "componentWillMount",
 61 |     "description": "React define componentWillMount",
 62 |     "body": [
 63 |       "componentWillMount: ->",
 64 |       "\t$1"
 65 |     ]
 66 |   },
 67 |   "componentDidMount": {
 68 |     "prefix": "componentDidMount",
 69 |     "description": "React define componentDidMount",
 70 |     "body": [
 71 |       "componentDidMount: ->",
 72 |       "\t$1"
 73 |     ]
 74 |   },
 75 |   "componentWillReceiveProps": {
 76 |     "prefix": "componentWillReceiveProps",
 77 |     "description": "React define componentWillReceiveProps",
 78 |     "body": [
 79 |       "componentWillReceiveProps: (nextProps) ->",
 80 |       "\t$1"
 81 |     ]
 82 |   },
 83 |   "shouldComponentUpdate": {
 84 |     "prefix": "shouldComponentUpdate",
 85 |     "description": "React define shouldComponentUpdate",
 86 |     "body": [
 87 |       "shouldComponentUpdate: (nextProps, nextState) ->",
 88 |       "\t$1"
 89 |     ]
 90 |   },
 91 |   "componentWillUpdate": {
 92 |     "prefix": "componentWillUpdate",
 93 |     "description": "React define componentWillUpdate",
 94 |     "body": [
 95 |       "componentWillUpdate: (nextProps, nextState) ->",
 96 |       "\t$1"
 97 |     ]
 98 |   },
 99 |   "componentDidUpdate": {
100 |     "prefix": "componentDidUpdate",
101 |     "description": "React define componentDidUpdate",
102 |     "body": [
103 |       "componentDidUpdate: (prevProps, prevState) ->",
104 |       "\t$1"
105 |     ]
106 |   },
107 |   "componentWillUnmount": {
108 |     "prefix": "componentWillUnmount",
109 |     "description": "React define componentWillUnmount",
110 |     "body": [
111 |       "componentWillUnmount: ->",
112 |       "\t$1"
113 |     ]
114 |   }
115 | }
116 | 


--------------------------------------------------------------------------------
/lua/user/lsp/null-ls.lua:
--------------------------------------------------------------------------------
  1 | local null_ls_status_ok, null_ls = pcall(require, "null-ls")
  2 | if not null_ls_status_ok then
  3 |   return
  4 | end
  5 | 
  6 | -- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/formatting
  7 | local formatting = null_ls.builtins.formatting
  8 | -- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/diagnostics
  9 | -- local diagnostics = null_ls.builtins.diagnostics
 10 | 
 11 | -- https://github.com/prettier-solidity/prettier-plugin-solidity
 12 | 
 13 | local opts = {
 14 | 
 15 |   debug = false,
 16 |   sources = {
 17 |     -- formatting.prettier.with({
 18 |     --   extra_filetypes = { "toml", 'vue' },
 19 |     --   extra_args = { "--single-quote",
 20 |     --     '--tab-width', '4' },
 21 |     --   filetypes = { "typescript", "typescriptreact", "javascript", "vue", "javascriptreact" },
 22 |     -- }),
 23 |     formatting.prettier,
 24 |     formatting.black.with({ extra_args = { "--fast" } }),
 25 |     formatting.stylua,
 26 |     formatting.clang_format,
 27 |     null_ls.builtins.code_actions.eslint,
 28 |     -- formatting.google_java_format, diagnostics.flake8,
 29 |   }
 30 | }
 31 | 
 32 | if vim.fn.has "mac" == 1 then
 33 |   table.insert(opts,
 34 |     formatting.prettier
 35 |   )
 36 | else
 37 |   table.insert(opts,
 38 |     formatting.prettierd
 39 |   )
 40 | end
 41 | 
 42 | null_ls.setup(opts)
 43 | 
 44 | -- local present, null_ls = pcall(require, "null-ls")
 45 | --
 46 | -- if not present then
 47 | --   return
 48 | -- end
 49 | --
 50 | -- local b = null_ls.builtins
 51 | --
 52 | -- local sources = {
 53 | --   -- Spell
 54 | --   b.completion.spell,
 55 | --   --b.diagnostics.misspell,
 56 | --   -- webdev stuff
 57 | --   b.formatting.prettier.with({
 58 | --     filetypes = {
 59 | --       "javascript",
 60 | --       "javascriptreact",
 61 | --       "typescript",
 62 | --       "typescriptreact",
 63 | --       --			"vue",
 64 | --       "css",
 65 | --       --			"scss",
 66 | --       "less",
 67 | --       "html",
 68 | --       "json",
 69 | --       -- "jsonc",
 70 | --       -- "yaml",
 71 | --       "markdown",
 72 | --       -- "graphql",
 73 | --       -- "php",
 74 | --     },
 75 | --     extra_args = { "--double-quote", "--jsx-single-quote", "--single-quote" },
 76 | --   }),
 77 | --   -- Lua
 78 | --   b.formatting.stylua,
 79 | --   -- b.diagnostics.luacheck,
 80 | --
 81 | --   -- Shell
 82 | --   b.formatting.shfmt,
 83 | --   b.diagnostics.shellcheck.with({ diagnostics_format = "#{m} [#{c}]" }),
 84 | --
 85 | --   -- cpp
 86 | --   b.formatting.clang_format,
 87 | --
 88 | --   -- docker
 89 | --   --b.diagnostics.hadolint,
 90 | --
 91 | --   -- php
 92 | --   -- b.formatting.phpcsfixer,
 93 | -- }
 94 | --
 95 | -- null_ls.setup({
 96 | --   debug = true,
 97 | --   sources = sources,
 98 | --   on_attach = function(client)
 99 | --     -- if vim.version().major > 7 then
100 | --     if client.server_capabilities.documentFormattingProvider then
101 | --       vim.cmd("autocmd BufWritePre <buffer> lua vim.lsp.buf.format()")
102 | --       vim.o.laststatus = 3
103 | --     end
104 | --     -- else
105 | --     --   if client.server_capabilities.document_formatting then
106 | --     --     vim.cmd("autocmd BufWritePre <buffer> lua vim.lsp.buf.format()")
107 | --     --
108 | --     --     vim.o.laststatus = 3
109 | --     --   end
110 | --     -- end
111 | --   end,
112 | -- })
113 | 


--------------------------------------------------------------------------------
/cool_snippets/javascript-ember.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "eapp": {
  3 |     "prefix": "eapp",
  4 |     "description": "App.Name = Ember.Application.create({});",
  5 |     "body": [
  6 |       "import Application from '@ember/application';",
  7 |       "",
  8 |       "export default Application.extend({",
  9 |       "\t${0://Properties here...}",
 10 |       "\\});"
 11 |     ],
 12 |     "luasnip": {
 13 |       "priority": -50
 14 |     }
 15 |   },
 16 |   "emod": {
 17 |     "prefix": "emod",
 18 |     "description": "import DS from 'ember-data';",
 19 |     "body": [
 20 |       "import DS from 'ember-data';",
 21 |       "",
 22 |       "export default DS.Model.extend({",
 23 |       "\t${0://Properties here...}",
 24 |       "\\});"
 25 |     ]
 26 |   },
 27 |   "econtroller": {
 28 |     "prefix": "econtroller",
 29 |     "description": "import Controller from '@ember/controller';",
 30 |     "body": [
 31 |       "import Controller from '@ember/controller';",
 32 |       "",
 33 |       "export default Controller.extend({",
 34 |       "\t${0://Properties here...}",
 35 |       "\\});"
 36 |     ]
 37 |   },
 38 |   "eroute": {
 39 |     "prefix": "eroute",
 40 |     "description": "import Route from '@ember/routing/route';",
 41 |     "body": [
 42 |       "import Route from '@ember/routing/route';",
 43 |       "",
 44 |       "export default Route.extend({",
 45 |       "\t${0://Properties here...}",
 46 |       "\\});"
 47 |     ]
 48 |   },
 49 |   "ecomponent": {
 50 |     "prefix": "ecomponent",
 51 |     "description": "import Component from '@ember/component';",
 52 |     "body": [
 53 |       "import Component from '@ember/component';",
 54 |       "",
 55 |       "export default Component.extend({",
 56 |       "\t${0://Properties here...}",
 57 |       "\\});"
 58 |     ]
 59 |   },
 60 |   "eobj": {
 61 |     "prefix": "eobj",
 62 |     "description": "import EmberObject from '@ember/object';",
 63 |     "body": [
 64 |       "import EmberObject from '@ember/object';",
 65 |       "",
 66 |       "export default EmberObject.extend({",
 67 |       "\t${0://Properties here...}",
 68 |       "\\});"
 69 |     ]
 70 |   },
 71 |   "emix": {
 72 |     "prefix": "emix",
 73 |     "description": "App.MixinName = Ember.Model.extend({...});",
 74 |     "body": [
 75 |       "import Mixin from '@ember/object/mixin';",
 76 |       "",
 77 |       "export default Mixin.create({",
 78 |       "\t${0://Properties here...}",
 79 |       "\\});"
 80 |     ]
 81 |   },
 82 |   "eget": {
 83 |     "prefix": "eget",
 84 |     "description": "this.get('property');",
 85 |     "body": "${1:this}.get('${2:property}');"
 86 |   },
 87 |   "eset": {
 88 |     "prefix": "eset",
 89 |     "description": "this.set('property', value);",
 90 |     "body": "${1:this}.set('${2:property}', ${3:value});"
 91 |   },
 92 |   "cproimport": {
 93 |     "prefix": "cproimport",
 94 |     "description": "import { computed } from '@ember/object';",
 95 |     "body": "import { computed \\} from '@ember/object';"
 96 |   },
 97 |   "cpro": {
 98 |     "prefix": "cpro",
 99 |     "description": "property_name: computed('...', function() {...}),",
100 |     "body": [
101 |       "${1:property_name}: computed('${3:argument}', function() {",
102 |       "\t${0://body...}",
103 |       "\\}),"
104 |     ]
105 |   },
106 |   "prooimport": {
107 |     "prefix": "prooimport",
108 |     "description": "import { observer } from '@ember/object';",
109 |     "body": "import { observer \\} from '@ember/object';"
110 |   },
111 |   "proo": {
112 |     "prefix": "proo",
113 |     "description": "property_name: observer('...', function() {...}),",
114 |     "body": [
115 |       "${1:property_name}: observer('${3:argument}', function() {",
116 |       "\t${0://body...}",
117 |       "\\}),"
118 |     ]
119 |   }
120 | }
121 | 


--------------------------------------------------------------------------------
/cool_snippets/cpp.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "ponce": {
  3 |     "prefix": "ponce",
  4 |     "description": "#pragma once include guard",
  5 |     "body": [
  6 |       "#pragma once",
  7 |       ""
  8 |     ],
  9 |     "luasnip": {
 10 |       "priority": -49
 11 |     }
 12 |   },
 13 |   "main": {
 14 |     "prefix": "main",
 15 |     "body": [
 16 |       "int main(int argc, char *argv[])",
 17 |       "{",
 18 |       "\t$0",
 19 |       "\treturn 0;",
 20 |       "\\}"
 21 |     ]
 22 |   },
 23 |   "nsa": {
 24 |     "prefix": "nsa",
 25 |     "description": "namespace alias",
 26 |     "body": "namespace ${1:alias} = ${2:namespace};"
 27 |   },
 28 |   "readfile": {
 29 |     "prefix": "readfile",
 30 |     "description": "read file (readF)",
 31 |     "body": [
 32 |       "std::vector<char> v;",
 33 |       "if (FILE *fp = fopen(${1:\"filename\"}, \"r\"))",
 34 |       "{",
 35 |       "\tchar buf[1024];",
 36 |       "\twhile(size_t len = fread(buf, 1, sizeof(buf), fp))",
 37 |       "\t\tv.insert(v.end(), buf, buf + len);",
 38 |       "\tfclose(fp);",
 39 |       "\\}"
 40 |     ]
 41 |   },
 42 |   "map": {
 43 |     "prefix": "map",
 44 |     "description": "std::map (map)",
 45 |     "body": "std::map<${1:key}, ${2:value}> map$0;"
 46 |   },
 47 |   "vector": {
 48 |     "prefix": "vector",
 49 |     "description": "std::vector (v)",
 50 |     "body": "std::vector<${1:char}> v$0;"
 51 |   },
 52 |   "tp": {
 53 |     "prefix": "tp",
 54 |     "description": "template <typename ..> (template)",
 55 |     "body": "template <typename ${1:_InputIter}>"
 56 |   },
 57 |   "boost_test": {
 58 |     "prefix": "boost_test",
 59 |     "description": "Boost test module",
 60 |     "body": [
 61 |       "#define BOOST_TEST_MODULE ${1:TestModuleName}",
 62 |       "#include <boost/test/included/unit_test.hpp>",
 63 |       "",
 64 |       "BOOST_AUTO_TEST_CASE(${2:TestCaseName})",
 65 |       "{",
 66 |       "\t${0:TestDefinition}",
 67 |       "\\}",
 68 |       ""
 69 |     ]
 70 |   },
 71 |   "boost_suite": {
 72 |     "prefix": "boost_suite",
 73 |     "description": "Boost test suite module",
 74 |     "body": [
 75 |       "#define BOOST_TEST_MODULE ${1:TestModuleName}",
 76 |       "#include <boost/test/included/unit_test.hpp>",
 77 |       "",
 78 |       "BOOST_AUTO_TEST_SUITE(${2:SuiteName})",
 79 |       "",
 80 |       "BOOST_AUTO_TEST_CASE(${3:TestCaseName})",
 81 |       "{",
 82 |       "\t${0:TestDefinition}",
 83 |       "\\}",
 84 |       "",
 85 |       "BOOST_AUTO_TEST_SUITE_END()",
 86 |       ""
 87 |     ]
 88 |   },
 89 |   "boost_test_fixture": {
 90 |     "prefix": "boost_test_fixture",
 91 |     "description": "Boost test module with fixture",
 92 |     "body": [
 93 |       "#define BOOST_TEST_MODULE ${1:TestModuleName}",
 94 |       "#include <boost/test/included/unit_test.hpp>",
 95 |       "",
 96 |       "struct ${2:FixtureName} {",
 97 |       "\t$2() {\\}",
 98 |       "\tvirtual ~$2() {\\}",
 99 |       "\t/* define members here */",
100 |       "\\};",
101 |       "",
102 |       "BOOST_FIXTURE_TEST_CASE(${3:SuiteName}, $2)",
103 |       "{",
104 |       "\t${0:TestDefinition}",
105 |       "\\}",
106 |       ""
107 |     ]
108 |   },
109 |   "boost_suite_fixture": {
110 |     "prefix": "boost_suite_fixture",
111 |     "description": "Boost test suite with fixture",
112 |     "body": [
113 |       "#define BOOST_TEST_MODULE ${1:TestModuleName}",
114 |       "#include <boost/test/included/unit_test.hpp>",
115 |       "",
116 |       "struct ${2:FixtureName} {",
117 |       "\t$2() {\\}",
118 |       "\tvirtual ~$2() {\\}",
119 |       "\t/* define members here */",
120 |       "\\};",
121 |       "",
122 |       "BOOST_FIXTURE_TEST_SUITE(${3:SuiteName}, $2)",
123 |       "",
124 |       "BOOST_AUTO_TEST_CASE(${4:TestCaseName})",
125 |       "{",
126 |       "\t${0:TestDefinition}",
127 |       "\\}",
128 |       "",
129 |       "BOOST_AUTO_TEST_SUITE_END()",
130 |       ""
131 |     ]
132 |   }
133 | }
134 | 


--------------------------------------------------------------------------------
/cool_snippets/objc.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "Imp": {
  3 |     "prefix": "Imp",
  4 |     "description": "#import <> (Imp)",
  5 |     "body": "#import <${1:Cocoa/Cocoa.h}>"
  6 |   },
  7 |   "array": {
  8 |     "prefix": "array",
  9 |     "description": "NSArray (array)",
 10 |     "body": "NSMutableArray *${1:array} = [NSMutableArray array];"
 11 |   },
 12 |   "dict": {
 13 |     "prefix": "dict",
 14 |     "description": "NSDictionary (dict)",
 15 |     "body": "NSMutableDictionary *${1:dict} = [NSMutableDictionary dictionary];"
 16 |   },
 17 |   "forarray": {
 18 |     "prefix": "forarray",
 19 |     "description": "for NSArray loop (forarray)",
 20 |     "body": [
 21 |       "unsigned int\t${1:object}Count = [${2:array} count];",
 22 |       "",
 23 |       "for(unsigned int index = 0; index < $1Count; index += 1)",
 24 |       "{",
 25 |       "\t${3:id}\t$1 = [$2 objectAtIndex:index];",
 26 |       "\t$0",
 27 |       "\\}"
 28 |     ]
 29 |   },
 30 |   "sel": {
 31 |     "prefix": "sel",
 32 |     "description": "@selector",
 33 |     "body": "@selector(${1:method}:)"
 34 |   },
 35 |   "thread": {
 36 |     "prefix": "thread",
 37 |     "description": "Detach New NSThread",
 38 |     "body": "[NSThread detachNewThreadSelector:@selector(${1:method}:) toTarget:${2:aTarget} withObject:${3:anArgument}]"
 39 |   },
 40 |   "I": {
 41 |     "prefix": "I",
 42 |     "description": "Initialize Implementation (I)",
 43 |     "body": [
 44 |       "+ (void)initialize",
 45 |       "{",
 46 |       "\t[[NSUserDefaults standardUserDefaults] registerDefaults:[NSDictionary dictionaryWithObjectsAndKeys:",
 47 |       "\t\t$0@\"value\", @\"key\",",
 48 |       "\t\tnil]];",
 49 |       "\\}"
 50 |     ]
 51 |   },
 52 |   "bind": {
 53 |     "prefix": "bind",
 54 |     "description": "Key:value binding (bind)",
 55 |     "body": "bind:@\"${1:binding}\" toObject:${2:observableController} withKeyPath:@\"${3:keyPath}\" options:${4:nil}"
 56 |   },
 57 |   "focus": {
 58 |     "prefix": "focus",
 59 |     "description": "Lock Focus",
 60 |     "body": [
 61 |       "[self lockFocus];",
 62 |       "$0",
 63 |       "[self unlockFocus];"
 64 |     ]
 65 |   },
 66 |   "pool": {
 67 |     "prefix": "pool",
 68 |     "description": "NSAutoreleasePool (pool)",
 69 |     "body": [
 70 |       "NSAutoreleasePool *pool = [NSAutoreleasePool new];",
 71 |       "$0",
 72 |       "[pool drain];"
 73 |     ]
 74 |   },
 75 |   "alert": {
 76 |     "prefix": "alert",
 77 |     "description": "NSRunAlertPanel (alert)",
 78 |     "body": [
 79 |       "int choice = NSRunAlertPanel(@\"${1:Something important!}\", @\"${2:Something important just happend, and now I need to ask you, do you want to continue?}\", @\"${3:Continue}\", @\"${4:Cancel}\", nil);",
 80 |       "if(choice == NSAlertDefaultReturn) // \"$3\"",
 81 |       "{",
 82 |       "\t$0;",
 83 |       "\\}",
 84 |       "else if(choice == NSAlertAlternateReturn) // \"$4\"",
 85 |       "{",
 86 |       "\t\t$0",
 87 |       "\\}"
 88 |     ]
 89 |   },
 90 |   "format": {
 91 |     "prefix": "format",
 92 |     "description": "NSString stringWithFormat (format)",
 93 |     "body": "[NSString stringWithFormat:@\"$1\", $2]$0"
 94 |   },
 95 |   "getprefs": {
 96 |     "prefix": "getprefs",
 97 |     "description": "Read from defaults (getprefs)",
 98 |     "body": "[[NSUserDefaults standardUserDefaults] objectForKey:${1:key}];"
 99 |   },
100 |   "gsave": {
101 |     "prefix": "gsave",
102 |     "description": "Save and Restore Graphics Context (gsave)",
103 |     "body": [
104 |       "[NSGraphicsContext saveGraphicsState];",
105 |       "$0",
106 |       "[NSGraphicsContext restoreGraphicsState];",
107 |       ""
108 |     ]
109 |   },
110 |   "syn": {
111 |     "prefix": "syn",
112 |     "description": "Synthesize",
113 |     "body": "@synthesize ${1:property};"
114 |   },
115 |   "setprefs": {
116 |     "prefix": "setprefs",
117 |     "description": "Write to defaults (setprefs)",
118 |     "body": "[[NSUserDefaults standardUserDefaults] setObject:${1:object} forKey:${2:key}];"
119 |   }
120 | }
121 | 


--------------------------------------------------------------------------------
/cool_snippets/perl.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "ife": {
  3 |     "prefix": "ife",
  4 |     "description": "Conditional if..else (ife)",
  5 |     "body": [
  6 |       "if ($1) {",
  7 |       "\t${2:# body...}",
  8 |       "\\}",
  9 |       "else {",
 10 |       "\t${3:# else...}",
 11 |       "\\}",
 12 |       ""
 13 |     ],
 14 |     "luasnip": {
 15 |       "priority": -50
 16 |     }
 17 |   },
 18 |   "ifee": {
 19 |     "prefix": "ifee",
 20 |     "description": "Conditional if..elsif..else (ifee)",
 21 |     "body": [
 22 |       "if ($1) {",
 23 |       "\t${2:# body...}",
 24 |       "\\}",
 25 |       "elsif ($3) {",
 26 |       "\t${4:# elsif...}",
 27 |       "\\}",
 28 |       "else {",
 29 |       "\t${5:# else...}",
 30 |       "\\}",
 31 |       ""
 32 |     ]
 33 |   },
 34 |   "xunless": {
 35 |     "prefix": "xunless",
 36 |     "description": "Conditional one-line (unless)",
 37 |     "body": [
 38 |       "${1:expression} unless ${2:condition};",
 39 |       ""
 40 |     ]
 41 |   },
 42 |   "xif": {
 43 |     "prefix": "xif",
 44 |     "description": "Conditional one-line (xif)",
 45 |     "body": [
 46 |       "${1:expression} if ${2:condition};",
 47 |       ""
 48 |     ]
 49 |   },
 50 |   "sub": {
 51 |     "prefix": "sub",
 52 |     "description": "Function (sub)",
 53 |     "body": [
 54 |       "sub ${1:function_name} {",
 55 |       "\t${2:# body...}",
 56 |       "\\}",
 57 |       ""
 58 |     ]
 59 |   },
 60 |   "xfore": {
 61 |     "prefix": "xfore",
 62 |     "description": "Loop one-line (xforeach)",
 63 |     "body": [
 64 |       "${1:expression} foreach @${2:array};",
 65 |       ""
 66 |     ]
 67 |   },
 68 |   "xwhile": {
 69 |     "prefix": "xwhile",
 70 |     "description": "Loop one-line (xwhile)",
 71 |     "body": [
 72 |       "${1:expression} while ${2:condition};",
 73 |       ""
 74 |     ]
 75 |   },
 76 |   "test": {
 77 |     "prefix": "test",
 78 |     "description": "Test",
 79 |     "body": [
 80 |       "#!/usr/bin/env perl -w",
 81 |       "",
 82 |       "use strict;",
 83 |       "use Test::More tests => ${1:1};",
 84 |       "use ${2:ModuleName};",
 85 |       "",
 86 |       "ok(${3:assertion});",
 87 |       ""
 88 |     ]
 89 |   },
 90 |   "eval": {
 91 |     "prefix": "eval",
 92 |     "description": "eval",
 93 |     "body": [
 94 |       "local \\$@;",
 95 |       "eval {",
 96 |       "\t${1:# do something risky...}",
 97 |       "\\};",
 98 |       "if (my \\$${2:exception} = \\$@) {",
 99 |       "\t${3:# handle failure...}",
100 |       "\\}",
101 |       ""
102 |     ]
103 |   },
104 |   "for": {
105 |     "prefix": "for",
106 |     "description": "for",
107 |     "body": [
108 |       "for (my \\$${1:var} = 0; \\$$1 < ${2:expression}; \\$$1++) {",
109 |       "\t${3:# body...}",
110 |       "\\}",
111 |       ""
112 |     ]
113 |   },
114 |   "fore": {
115 |     "prefix": "fore",
116 |     "description": "foreach",
117 |     "body": [
118 |       "foreach ${1:my \\$${2:x}} (@${3:array}) {",
119 |       "\t${4:# body...}",
120 |       "\\}",
121 |       ""
122 |     ]
123 |   },
124 |   "if": {
125 |     "prefix": "if",
126 |     "description": "if",
127 |     "body": [
128 |       "if ($1) {",
129 |       "\t${2:# body...}",
130 |       "\\}",
131 |       ""
132 |     ]
133 |   },
134 |   "slurp": {
135 |     "prefix": "slurp",
136 |     "description": "slurp",
137 |     "body": [
138 |       "my \\$${1:var} = do { local \\$/ = undef; open my \\$fh, '<', ${2:\\$file}; <\\$fh> \\};",
139 |       ""
140 |     ]
141 |   },
142 |   "unless": {
143 |     "prefix": "unless",
144 |     "description": "unless",
145 |     "body": [
146 |       "unless ($1) {",
147 |       "\t${2:# body...}",
148 |       "\\}",
149 |       ""
150 |     ]
151 |   },
152 |   "while": {
153 |     "prefix": "while",
154 |     "description": "while",
155 |     "body": [
156 |       "while ($1) {",
157 |       "\t${2:# body...}",
158 |       "\\}",
159 |       ""
160 |     ]
161 |   },
162 |   "until": {
163 |     "prefix": "until",
164 |     "description": "until",
165 |     "body": [
166 |       "until ($1) {",
167 |       "\t${2:# body...}",
168 |       "\\}",
169 |       ""
170 |     ]
171 |   }
172 | }
173 | 


--------------------------------------------------------------------------------
/ftplugin/java.lua:
--------------------------------------------------------------------------------
  1 | -- local config = {
  2 | -- 	cmd = { vim.fn.expand("~/.local/share/nvim/mason/bin/jdtls") },
  3 | -- 	-- cmd = {'/path/to/jdt-language-server/bin/jdtls'},
  4 | -- 	root_dir = vim.fs.dirname(vim.fs.find({ "gradlew", ".git", "mvnw" }, { upward = true })[1]),
  5 | -- }
  6 | --
  7 | -- require("jdtls").start_or_attach(config)
  8 | 
  9 | local home = os.getenv("HOME")
 10 | local workspace_path = home .. "/.local/share/nvim/jdtls-workspace/"
 11 | local project_name = vim.fn.fnamemodify(vim.fn.getcwd(), ":p:h:t")
 12 | local workspace_dir = workspace_path .. project_name
 13 | 
 14 | local status, jdtls = pcall(require, "jdtls")
 15 | if not status then
 16 | 	return
 17 | end
 18 | local extendedClientCapabilities = jdtls.extendedClientCapabilities
 19 | 
 20 | local config = {
 21 | 	root_dir = require("jdtls.setup").find_root({ ".git", "mvnw", "gradlew", "pom.xml", "build.gradle" }),
 22 | 
 23 | 	settings = {
 24 | 		java = {
 25 | 			signatureHelp = { enabled = true },
 26 | 			extendedClientCapabilities = extendedClientCapabilities,
 27 | 			maven = {
 28 | 				downloadSources = true,
 29 | 			},
 30 | 			referencesCodeLens = {
 31 | 				enabled = true,
 32 | 			},
 33 | 			references = {
 34 | 				includeDecompiledSources = true,
 35 | 			},
 36 | 			inlayHints = {
 37 | 				parameterNames = {
 38 | 					enabled = "all", -- literals, all, none
 39 | 				},
 40 | 			},
 41 | 			format = {
 42 | 				enabled = false,
 43 | 			},
 44 | 		},
 45 | 	},
 46 | 
 47 | 	init_options = {
 48 | 		bundles = {},
 49 | 	},
 50 | }
 51 | 
 52 | -- add the config based on the os
 53 | if vim.fn.has("mac") == 1 then
 54 | 	config["cmd"] = {
 55 | 		"java",
 56 | 		"-Declipse.application=org.eclipse.jdt.ls.core.id1",
 57 | 		"-Dosgi.bundles.defaultStartLevel=4",
 58 | 		"-Declipse.product=org.eclipse.jdt.ls.core.product",
 59 | 		"-Dlog.protocol=true",
 60 | 		"-Dlog.level=ALL",
 61 | 		"-Xmx1g",
 62 | 		"--add-modules=ALL-SYSTEM",
 63 | 		"--add-opens",
 64 | 		"java.base/java.util=ALL-UNNAMED",
 65 | 		"--add-opens",
 66 | 		"java.base/java.lang=ALL-UNNAMED",
 67 | 		"-javaagent:" .. home .. "/.local/share/nvim/mason/packages/jdtls/lombok.jar",
 68 | 		"-jar",
 69 | 		vim.fn.glob(home .. "/.local/share/nvim/mason/packages/jdtls/plugins/org.eclipse.equinox.launcher_*.jar"),
 70 | 		"-configuration",
 71 | 		home .. "/.local/share/nvim/mason/packages/jdtls/config_mac",
 72 | 		"-data",
 73 | 		workspace_dir,
 74 | 	}
 75 | else
 76 | 	config["cmd"] = {
 77 | 		"java",
 78 | 		"-Declipse.application=org.eclipse.jdt.ls.core.id1",
 79 | 		"-Dosgi.bundles.defaultStartLevel=4",
 80 | 		"-Declipse.product=org.eclipse.jdt.ls.core.product",
 81 | 		"-Dlog.protocol=true",
 82 | 		"-Dlog.level=ALL",
 83 | 		"-Xmx1g",
 84 | 		"--add-modules=ALL-SYSTEM",
 85 | 		"--add-opens",
 86 | 		"java.base/java.util=ALL-UNNAMED",
 87 | 		"--add-opens",
 88 | 		"java.base/java.lang=ALL-UNNAMED",
 89 | 		"-javaagent:" .. home .. "/.local/share/nvim/mason/packages/jdtls/lombok.jar",
 90 | 		"-jar",
 91 | 		vim.fn.glob(home .. "/.local/share/nvim/mason/packages/jdtls/plugins/org.eclipse.equinox.launcher_*.jar"),
 92 | 		"-configuration",
 93 | 		home .. "/.local/share/nvim/mason/packages/jdtls/config_linux",
 94 | 		"-data",
 95 | 		workspace_dir,
 96 | 	}
 97 | end
 98 | 
 99 | require("jdtls").start_or_attach(config)
100 | 
101 | vim.keymap.set("n", "<leader>vo", "<Cmd>lua require'jdtls'.organize_imports()<CR>", { desc = "Organize Imports" })
102 | vim.keymap.set("n", "<leader>vrv", "<Cmd>lua require('jdtls').extract_variable()<CR>", { desc = "Extract Variable" })
103 | vim.keymap.set(
104 | 	"v",
105 | 	"<leader>vrv",
106 | 	"<Esc><Cmd>lua require('jdtls').extract_variable(true)<CR>",
107 | 	{ desc = "Extract Variable" }
108 | )
109 | vim.keymap.set("n", "<leader>vrc", "<Cmd>lua require('jdtls').extract_constant()<CR>", { desc = "Extract Constant" })
110 | vim.keymap.set(
111 | 	"v",
112 | 	"<leader>vrc",
113 | 	"<Esc><Cmd>lua require('jdtls').extract_constant(true)<CR>",
114 | 	{ desc = "Extract Constant" }
115 | )
116 | vim.keymap.set(
117 | 	"v",
118 | 	"<leader>vrm",
119 | 	"<Esc><Cmd>lua require('jdtls').extract_method(true)<CR>",
120 | 	{ desc = "Extract Method" }
121 | )
122 | 


--------------------------------------------------------------------------------
/lua/user/options.lua:
--------------------------------------------------------------------------------
 1 | local global = vim.g
 2 | vim.opt.backup = false                         -- creates a backup file
 3 | vim.opt.clipboard = "unnamedplus"              -- allows neovim to access the system clipboard
 4 | vim.opt.cmdheight = 1                          -- more space in the neovim command line for displaying messages
 5 | vim.opt.completeopt = { "preview", "menuone" } -- mostly just for cmp
 6 | vim.opt.conceallevel = 0                       -- so that `` is visible in markdown files
 7 | vim.opt.fileencoding = "utf-8"                 -- the encoding written to a file
 8 | vim.opt.hlsearch = true                        -- highlight all matches on previous search pattern
 9 | vim.opt.ignorecase = true                      -- ignore case in search patterns
10 | vim.opt.mouse = "a"                            -- allow the mouse to be used in neovim
11 | vim.opt.pumheight = 10                         -- pop up menu height
12 | vim.opt.showmode = false                       -- we don't need to see things like -- INSERT -- anymore
13 | vim.opt.showtabline = 0                        -- always show tabs
14 | vim.opt.smartcase = true                       -- smart case
15 | vim.opt.smartindent = true                     -- make indenting smarter again
16 | vim.opt.splitbelow = true                      -- force all horizontal splits to go below current window
17 | vim.opt.splitright = true                      -- force all vertical splits to go to the right of current window
18 | vim.opt.swapfile = false                       -- creates a swapfile
19 | vim.opt.termguicolors = true                   -- set term gui colors (most terminals support this)
20 | vim.opt.timeoutlen = 300                       -- time to wait for a mapped sequence to complete (in milliseconds)
21 | vim.opt.undofile = true                        -- enable persistent undo
22 | vim.opt.updatetime = 50                        -- faster completion (4000ms default)
23 | vim.opt.writebackup = false                    -- if a file is being edited by another program (or was written to file while editing with another program), it is not allowed to be edited
24 | vim.opt.expandtab = true                       -- convert tabs to spaces
25 | vim.opt.shiftwidth = 2                         -- the number of spaces inserted for each indentation
26 | vim.opt.tabstop = 2                            -- insert 2 spaces for a tab
27 | vim.opt.cursorline = true                      -- highlight the current line
28 | vim.opt.number = true                          -- set numbered lines
29 | vim.opt.showcmd = false                        -- hide (partial) command in the last line of the screen (for performance)
30 | vim.opt.ruler = false                          -- hide the line and column number of the cursor position
31 | vim.opt.numberwidth = 4                        -- minimal number of columns to use for the line number {default 4}
32 | vim.opt.signcolumn = "yes"                     -- always show the sign column, otherwise it would shift the text each time
33 | vim.opt.wrap = true                            -- display lines as one long line
34 | vim.opt.scrolloff = 8                          -- minimal number of screen lines to keep above and below the cursor
35 | vim.opt.sidescrolloff = 8                      -- minimal number of screen columns to keep to the left and right of the cursor if wrap is `false`
36 | vim.opt.guifont = "monospace:h17"              -- the font used in graphical neovim applications
37 | vim.opt.fillchars.eob = " "                    -- show empty lines at the end of a buffer as ` ` {default `~`}
38 | vim.opt.shortmess:append("c")                  -- hide all the completion messages, e.g. "-- XXX completion (YYY)", "match 1 of 2", "The only match", "Pattern not found"
39 | vim.opt.whichwrap:append("<,>,[,],h,l")        -- keys allowed to move to the previous/next line when the beginning/end of line is reached
40 | vim.opt.iskeyword:append("-")                  -- treats words with `-` as single words
41 | vim.g.skip_ts_context_commentstring_module = true
42 | -- vim.opt.foldmethod = "expr"
43 | -- vim.opt.foldexpr = "nvim_treesitter#foldexpr()"
44 | global.luasnippets_path = vim.fn.stdpath("config") .. "/cool_snippets"
45 | 


--------------------------------------------------------------------------------
/lua/user/gitsigns.lua:
--------------------------------------------------------------------------------
  1 | local status_ok, gitsigns = pcall(require, "gitsigns")
  2 | if not status_ok then
  3 | 	return
  4 | end
  5 | 
  6 | -- gitsigns.setup {
  7 | --   signs = {
  8 | --     add = { hl = "GitSignsAdd", text = "▎", numhl = "GitSignsAddNr", linehl = "GitSignsAddLn" },
  9 | --     change = { hl = "GitSignsChange", text = "▎", numhl = "GitSignsChangeNr", linehl = "GitSignsChangeLn" },
 10 | --     delete = { hl = "GitSignsDelete", text = "", numhl = "GitSignsDeleteNr", linehl = "GitSignsDeleteLn" },
 11 | --     topdelete = { hl = "GitSignsDelete", text = "", numhl = "GitSignsDeleteNr", linehl = "GitSignsDeleteLn" },
 12 | --     changedelete = { hl = "GitSignsChange", text = "▎", numhl = "GitSignsChangeNr", linehl = "GitSignsChangeLn" },
 13 | --   },
 14 | --   signcolumn = true,  -- Toggle with `:Gitsigns toggle_signs`
 15 | --   numhl      = false, -- Toggle with `:Gitsigns toggle_numhl`
 16 | --   linehl     = false, -- Toggle with `:Gitsigns toggle_linehl`
 17 | --   word_diff  = false, -- Toggle with `:Gitsigns toggle_word_diff`
 18 | --   watch_gitdir = {
 19 | --     interval = 1000,
 20 | --     follow_files = true
 21 | --   },
 22 | --   attach_to_untracked = true,
 23 | --   current_line_blame = false, -- Toggle with `:Gitsigns toggle_current_line_blame`
 24 | --   current_line_blame_opts = {
 25 | --     virt_text = true,
 26 | --     virt_text_pos = 'eol', -- 'eol' | 'overlay' | 'right_align'
 27 | --     delay = 1000,
 28 | --     ignore_whitespace = false,
 29 | --   },
 30 | --   current_line_blame_formatter = '<author>, <author_time:%Y-%m-%d> - <summary>',
 31 | --   sign_priority = 6,
 32 | --   update_debounce = 100,
 33 | --   status_formatter = nil, -- Use default
 34 | --   max_file_length = 40000, -- Disable if file is longer than this (in lines)
 35 | --   preview_config = {
 36 | --     -- Options passed to nvim_open_win
 37 | --     border = 'single',
 38 | --     style = 'minimal',
 39 | --     relative = 'cursor',
 40 | --     row = 0,
 41 | --     col = 1
 42 | --   },
 43 | --   yadm = {
 44 | --     enable = false
 45 | --   },
 46 | -- }
 47 | 
 48 | local icons = require("user.icons")
 49 | 
 50 | vim.api.nvim_set_hl(0, "GitSignsAdd", { link = "GitSignsAdd" })
 51 | vim.api.nvim_set_hl(0, "GitSignsAddNr", { link = "GitSignsAddNr" })
 52 | vim.api.nvim_set_hl(0, "GitSignsAddLn", { link = "GitSignsAddLn" })
 53 | vim.api.nvim_set_hl(0, "GitSignsChange", { link = "GitSignsChange" })
 54 | vim.api.nvim_set_hl(0, "GitSignsChangeNr", { link = "GitSignsChangeNr" })
 55 | vim.api.nvim_set_hl(0, "GitSignsChangeLn", { link = "GitSignsChangeLn" })
 56 | vim.api.nvim_set_hl(0, "GitSignsDelete", { link = "GitSignsDelete" })
 57 | vim.api.nvim_set_hl(0, "GitSignsDeleteNr", { link = "GitSignsDeleteNr" })
 58 | vim.api.nvim_set_hl(0, "GitSignsDeleteLn", { link = "GitSignsDeleteLn" })
 59 | vim.api.nvim_set_hl(0, "GitSignsChangedelete", { link = "GitSignsChange" })
 60 | vim.api.nvim_set_hl(0, "GitSignsChangedeleteLn", { link = "GitSignsChangeLn" })
 61 | vim.api.nvim_set_hl(0, "GitSignsChangedeleteNr", { link = "GitSignsChangeNr" })
 62 | vim.api.nvim_set_hl(0, "GitSignsTopdelete", { link = "GitSignsDelete" })
 63 | vim.api.nvim_set_hl(0, "GitSignsTopdeleteLn", { link = "GitSignsDeleteLn" })
 64 | vim.api.nvim_set_hl(0, "GitSignsTopdeleteNr", { link = "GitSignsDeleteNr" })
 65 | 
 66 | local gitSignsOpts = {
 67 | 
 68 | 	signcolumn = true,
 69 | 	numhl = false,
 70 | 	linehl = false,
 71 | 	word_diff = false,
 72 | 	watch_gitdir = {
 73 | 		interval = 1000,
 74 | 		follow_files = true,
 75 | 	},
 76 | 	attach_to_untracked = true,
 77 | 	current_line_blame = false, -- Toggle with `:Gitsigns toggle_current_line_blame`
 78 | 	current_line_blame_opts = {
 79 | 		virt_text = true,
 80 | 		virt_text_pos = "eol", -- 'eol' | 'overlay' | 'right_align'
 81 | 		delay = 1000,
 82 | 		ignore_whitespace = false,
 83 | 	},
 84 | 	current_line_blame_formatter = "<author>, <author_time:%Y-%m-%d> - <summary>",
 85 | 	sign_priority = 6,
 86 | 	status_formatter = nil, -- Use default
 87 | 	update_debounce = 200,
 88 | 	max_file_length = 40000,
 89 | 	preview_config = {
 90 | 		-- Options passed to nvim_open_win
 91 | 		border = "rounded",
 92 | 		style = "minimal",
 93 | 		relative = "cursor",
 94 | 		row = 0,
 95 | 		col = 1,
 96 | 	},
 97 | 	-- yadm = { enable = false },
 98 | }
 99 | 
100 | gitsigns.setup(gitSignsOpts)
101 | 


--------------------------------------------------------------------------------
/lua/user/lsp/mason.lua:
--------------------------------------------------------------------------------
  1 | local servers = {
  2 |   "cssls",
  3 |   "html",
  4 |   -- "clangd",
  5 |   "lua_ls",
  6 |   "tsserver",
  7 |   -- "vue-language-server",
  8 |   "pyright",
  9 |   "vuels",
 10 |   "volar",
 11 |   "astro",
 12 |   "bashls",
 13 |   "jdtls",
 14 |   "tailwindcss",
 15 |   "jsonls",
 16 |   "cssls",
 17 |   -- "intelephense",
 18 |   "phpactor",
 19 |   -- "yamlls",
 20 | }
 21 | 
 22 | 
 23 | -- -- local coq = require "coq"
 24 | 
 25 | -- local settings = {
 26 | --   ui = {
 27 | --     border = "none",
 28 | --     icons = {
 29 | --       package_installed = "◍",
 30 | --       package_pending = "◍",
 31 | --       package_uninstalled = "◍",
 32 | --     },
 33 | --   },
 34 | --   log_level = vim.log.levels.INFO,
 35 | --   max_concurrent_installers = 4,
 36 | -- }
 37 | 
 38 | -- require("mason").setup(settings)
 39 | -- -- require("mason-lspconfig").setup(coq.lsp_ensure_capabilities({
 40 | -- require("mason-lspconfig").setup({
 41 | --   ensure_installed = servers,
 42 | --   automatic_installation = true,
 43 | -- })
 44 | 
 45 | -- local lspconfig_status_ok, lspconfig = pcall(require, "lspconfig")
 46 | -- if not lspconfig_status_ok then
 47 | --   return
 48 | -- end
 49 | -- local opts = {}
 50 | 
 51 | -- for _, server in pairs(servers) do
 52 | --   opts = {
 53 | --     on_attach = require("user.lsp.handlers").on_attach,
 54 | --     capabilities = require("user.lsp.handlers").capabilities,
 55 | --   }
 56 | 
 57 | --   server = vim.split(server, "@")[1]
 58 | 
 59 | --   local require_ok, conf_opts = pcall(require, "user.lsp.settings." .. server)
 60 | --   if require_ok then
 61 | --     opts = vim.tbl_deep_extend("force", conf_opts, opts)
 62 | --   end
 63 | --   -- lspconfig[server].setup(coq.lsp_ensure_capabilities(opts))
 64 | --   lspconfig[server].setup(opts)
 65 | -- end
 66 | 
 67 | local present, mason = pcall(require, "mason")
 68 | 
 69 | if not present then
 70 |   print("mason not found")
 71 |   return
 72 | end
 73 | 
 74 | vim.api.nvim_create_augroup("_mason", { clear = true })
 75 | 
 76 | local options = {
 77 |   -- ensure_installed = "all",
 78 |   ui = {
 79 |     icons = {
 80 |       package_pending = " ",
 81 |       package_installed = " ",
 82 |       package_uninstalled = " ﮊ",
 83 |     },
 84 |     keymaps = {
 85 |       toggle_server_expand = "<CR>",
 86 |       install_server = "i",
 87 |       update_server = "u",
 88 |       check_server_version = "c",
 89 |       update_all_servers = "U",
 90 |       check_outdated_servers = "C",
 91 |       uninstall_server = "X",
 92 |       cancel_installation = "<C-c>",
 93 |     },
 94 |   },
 95 |   max_concurrent_installers = 10,
 96 | }
 97 | 
 98 | mason.setup(options)
 99 | 
100 | --require("mason").setup(settings)
101 | -- require("mason-lspconfig").setup(coq.lsp_ensure_capabilities({
102 | 
103 | local mConf = {
104 | 
105 |   ensure_installed = {
106 |     "bashls",
107 |     -- "clangd",
108 |     "cssls",
109 |     "html",
110 |     "jsonls",
111 |     "lua_ls",
112 |     "pyright",
113 |     -- "tsserver",
114 |     "jdtls",
115 |     "cmake",
116 |     "cssmodules_ls",
117 |     "dockerls",
118 |     "volar",
119 |     "phpactor",
120 |     "astro",
121 |     -- "intelephense",
122 |     "eslint",
123 |     -- "marksman",
124 |     "sqlls",
125 |     -- "vuels",
126 |     "tailwindcss",
127 |   },
128 |   automatic_installation = true,
129 | }
130 | 
131 | 
132 | -- Check if Go is executable and add gopls if it is
133 | if vim.fn.executable("go") == 1 then
134 |   print("inserting")
135 |   table.insert(servers, "gopls")
136 |   table.insert(mConf.ensure_installed, "gopls")
137 | end
138 | 
139 | require("mason-lspconfig").setup(mConf)
140 | 
141 | -- local lspconfig_status_ok, lspconfig = pcall(require, "lspconfig")
142 | -- if not lspconfig_status_ok then
143 | --   return
144 | -- end
145 | -- local opts = {}
146 | --
147 | -- for _, server in pairs(servers) do
148 | --   opts = {
149 | --     on_attach = require("user.lsp.handlers").on_attach,
150 | --     capabilities = require("user.lsp.handlers").capabilities,
151 | --   }
152 | --
153 | --   server = vim.split(server, "@")[1]
154 | --
155 | --   local require_ok, conf_opts = pcall(require, "user.lsp.settings." .. server)
156 | --   if require_ok then
157 | --     opts = vim.tbl_deep_extend("force", conf_opts, opts)
158 | --   end
159 | --   -- lspconfig[server].setup(coq.lsp_ensure_capabilities(opts))
160 | --   lspconfig[server].setup(opts)
161 | -- end
162 | --options = require("core.utils").load_override(options, "williamboman/mason.nvim")
163 | 
164 | --vim.api.nvim_create_user_command("MasonInstallAll", function()
165 | --  vim.cmd("MasonInstall " .. table.concat(options.ensure_installed, " "))
166 | --end, {})
167 | 


--------------------------------------------------------------------------------
/lua/user/noice.lua:
--------------------------------------------------------------------------------
 1 | local present, noice = pcall(require, "noice")
 2 | 
 3 | if not present then
 4 |   return
 5 | end
 6 | 
 7 | noice.setup({
 8 |   enabled = true, -- enables the Noice cmdline UI
 9 |   view = "cmdline_popup", -- view for rendering the cmdline. Change to `cmdline` to get a classic cmdline at the bottom
10 |   background_colour = "#000000",
11 |   opts = { buf_options = { filetype = "lua" } }, -- enable syntax highlighting in the cmdline
12 | 
13 |   -- -@type table<string, CmdlineFormat>
14 |   format = {
15 |     -- conceal: (default=true) This will hide the text in the cmdline that matches the pattern.
16 |     -- view: (default is cmdline view)
17 |     -- opts: any options passed to the view
18 |     -- icon_hl_group: optional hl_group for the icon
19 |     -- title: set to anything or empty string to hide
20 |     icons = {
21 |       ["/"] = { icon = " ", hl_group = "DiagnosticWarn" },
22 |       ["?"] = { icon = " ", hl_group = "DiagnosticWarn" },
23 |       [":"] = { icon = " ", hl_group = "DiagnosticInfo", firstc = false },
24 |     },
25 |     --     cmdline = { pattern = "^:", icon = "", lang = "vim" },
26 |     --     search_down = { kind = "search", pattern = "^/", icon = " ", lang = "regex" },
27 |     --     search_up = { kind = "search", pattern = "^%?", icon = " ", lang = "regex" },
28 |     --     filter = { pattern = "^:%s*!", icon = "$", lang = "bash" },
29 |     --     lua = { pattern = "^:%s*lua%s+", icon = "", lang = "lua" },
30 |     --     help = { pattern = "^:%s*he?l?p?%s+", icon = "" },
31 |     --     input = {}, -- Used by input()
32 |     --      -- lua = false, -- to disable a format, set to `false`
33 |   },
34 |   messages = {
35 |     -- NOTE: If you enable noice messages UI, noice cmdline UI is enabled
36 |     -- automatically. You cannot enable noice messages UI only.
37 |     -- It is current neovim implementation limitation.  It may be fixed later.
38 |     enabled = false, -- disable if you use native messages UI
39 |   },
40 |   popupmenu = {
41 |     enabled = true, -- disable if you use something like cmp-cmdline
42 |     ---@type 'nui'|'cmp'
43 |     backend = "cmp", -- backend to use to show regular cmdline completions
44 |     -- You can specify options for nui under `config.views.popupmenu`
45 |   },
46 |   history = {
47 |     -- options for the message history that you get with `:Noice`
48 |     view = "split",
49 |     opts = { enter = true },
50 |     filter = { event = "msg_show", ["not"] = { kind = { "search_count", "echo" } } },
51 |   },
52 |   notify = {
53 |     -- Noice can be used as `vim.notify` so you can route any notification like other messages
54 |     -- Notification messages have their level and other properties set.
55 |     -- event is always "notify" and kind can be any log level as a string
56 |     -- The default routes will forward notifications to nvim-notify
57 |     -- Benefit of using Noice for this is the routing and consistent history view
58 |     enabled = false,
59 |   },
60 |   hacks = {
61 |     -- due to https://github.com/neovim/neovim/issues/20416
62 |     -- messages are resent during a redraw. Noice detects this in most cases, but
63 |     -- some plugins (mostly vim plugns), can still cause loops.
64 |     -- When a loop is detected, Noice exits.
65 |     -- Enable this option to simply skip duplicate messages instead.
66 |     skip_duplicate_messages = false,
67 |   },
68 |   throttle = 1000 / 30, -- how frequently does Noice need to check for ui updates? This has no effect when in blocking mode.
69 |   --	---@type table<string, NoiceViewOptions>
70 |   --	views = {}, -- @see the section on views below
71 |   --	---@type NoiceRouteConfig[]
72 |   --	routes = {}, -- @see the section on routes below
73 |   --	---@type table<string, NoiceFilter>
74 |   --	status = {}, --@see the section on statusline components below
75 |   --	---@type NoiceFormatOptions
76 |   --	format = {}, -- @see section on formatting
77 |   lsp = {
78 |     -- override markdown rendering so that **cmp** and other plugins use **Treesitter**
79 |     override = {
80 |       ["vim.lsp.util.convert_input_to_markdown_lines"] = true,
81 |       ["vim.lsp.util.stylize_markdown"] = true,
82 |       ["cmp.entry.get_documentation"] = true,
83 |     },
84 |   },
85 |   -- you can enable a preset for easier configuration
86 |   presets = {
87 |     bottom_search = false, -- use a classic bottom cmdline for search
88 |     command_palette = false, -- position the cmdline and popupmenu together
89 |     long_message_to_split = true, -- long messages will be sent to a split
90 |     inc_rename = false, -- enables an input dialog for inc-rename.nvim
91 |     lsp_doc_border = true, -- add a border to hover docs and signature help
92 |   },
93 | })
94 | 


--------------------------------------------------------------------------------
/cool_snippets/blade.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "break": {
  3 |     "prefix": "break",
  4 |     "description": "@break",
  5 |     "body": "@break",
  6 |     "luasnip": {
  7 |       "priority": -49
  8 |     }
  9 |   },
 10 |   "component": {
 11 |     "prefix": "component",
 12 |     "description": "@component directive",
 13 |     "body": [
 14 |       "@component('$1')",
 15 |       "\t${2:$TM_SELECTED_TEXT}",
 16 |       "@endcomponent"
 17 |     ]
 18 |   },
 19 |   "each": {
 20 |     "prefix": "each",
 21 |     "description": "@each directive",
 22 |     "body": "@each('$1', \\$$2, '$3')"
 23 |   },
 24 |   "else": {
 25 |     "prefix": "else",
 26 |     "description": "@else directive",
 27 |     "body": "@else"
 28 |   },
 29 |   "eif": {
 30 |     "prefix": "eif",
 31 |     "description": "@else if directive",
 32 |     "body": [
 33 |       "@else if ($1)",
 34 |       "\t${2:$TM_SELECTED_TEXT}"
 35 |     ]
 36 |   },
 37 |   "for": {
 38 |     "prefix": "for",
 39 |     "description": "@for directive",
 40 |     "body": [
 41 |       "@for ($1)",
 42 |       "\t${2:$TM_SELECTED_TEXT}",
 43 |       "@endfor"
 44 |     ]
 45 |   },
 46 |   "foreach": {
 47 |     "prefix": "foreach",
 48 |     "description": "@foreach directive",
 49 |     "body": [
 50 |       "@foreach (\\$$1 as \\$$2)",
 51 |       "\t${3:$TM_SELECTED_TEXT}",
 52 |       "@endforeach"
 53 |     ]
 54 |   },
 55 |   "extends": {
 56 |     "prefix": "extends",
 57 |     "description": "@extends directive",
 58 |     "body": "@extends('$1')"
 59 |   },
 60 |   "if": {
 61 |     "prefix": "if",
 62 |     "description": "@if directive",
 63 |     "body": [
 64 |       "@if ($1)",
 65 |       "\t${2:$TM_SELECTED_TEXT}",
 66 |       "@endif"
 67 |     ]
 68 |   },
 69 |   "ife": {
 70 |     "prefix": "ife",
 71 |     "description": "@if @else structure",
 72 |     "body": [
 73 |       "@if ($1)",
 74 |       "\t${2:$TM_SELECTED_TEXT}",
 75 |       "@else",
 76 |       "\t${3:$TM_SELECTED_TEXT}",
 77 |       "@endif"
 78 |     ]
 79 |   },
 80 |   "include": {
 81 |     "prefix": "include",
 82 |     "description": "@include directive",
 83 |     "body": "@include('$1')"
 84 |   },
 85 |   "includeIf": {
 86 |     "prefix": "includeIf",
 87 |     "description": "@includeIf directive",
 88 |     "body": "@includeIf('$1')"
 89 |   },
 90 |   "isset": {
 91 |     "prefix": "isset",
 92 |     "description": "@isset directive",
 93 |     "body": [
 94 |       "@isset",
 95 |       "\t${1:$TM_SELECTED_TEXT}",
 96 |       "@endisset"
 97 |     ]
 98 |   },
 99 |   "inject": {
100 |     "prefix": "inject",
101 |     "description": "@inject directive",
102 |     "body": "@inject('$1', '$2')"
103 |   },
104 |   "lang": {
105 |     "prefix": "lang",
106 |     "description": "@lang directive",
107 |     "body": "@lang('$1')"
108 |   },
109 |   "php": {
110 |     "prefix": "php",
111 |     "description": "@php directive",
112 |     "body": [
113 |       "@php",
114 |       "\t${1:$TM_SELECTED_TEXT}",
115 |       "@endphp"
116 |     ]
117 |   },
118 |   "push": {
119 |     "prefix": "push",
120 |     "description": "@push directive",
121 |     "body": [
122 |       "@push('$1')",
123 |       "\t${2:$TM_SELECTED_TEXT}",
124 |       "@endpush"
125 |     ]
126 |   },
127 |   "section": {
128 |     "prefix": "section",
129 |     "description": "@section directive",
130 |     "body": "@section('$1')"
131 |   },
132 |   "show": {
133 |     "prefix": "show",
134 |     "description": "@show directive",
135 |     "body": "@show"
136 |   },
137 |   "slot": {
138 |     "prefix": "slot",
139 |     "description": "@slot directive",
140 |     "body": [
141 |       "@slot('$1')",
142 |       "\t${2:$TM_SELECTED_TEXT}",
143 |       "@endslot"
144 |     ]
145 |   },
146 |   "unless": {
147 |     "prefix": "unless",
148 |     "description": "@unless directive",
149 |     "body": [
150 |       "@unless",
151 |       "\t${1:$TM_SELECTED_TEXT}",
152 |       "@endunless"
153 |     ]
154 |   },
155 |   "verbatim": {
156 |     "prefix": "verbatim",
157 |     "description": "@verbatim directive",
158 |     "body": [
159 |       "@verbatim",
160 |       "\t${0:\\$VISUAL}",
161 |       "@endverbatim"
162 |     ]
163 |   },
164 |   "wh": {
165 |     "prefix": "wh",
166 |     "description": "@while directive",
167 |     "body": [
168 |       "@while ($1)",
169 |       "\t${2:$TM_SELECTED_TEXT}",
170 |       "@endwhile"
171 |     ]
172 |   },
173 |   "yield": {
174 |     "prefix": "yield",
175 |     "description": "@yield directive",
176 |     "body": "@yield('$1')"
177 |   },
178 |   "{": {
179 |     "prefix": "{",
180 |     "description": "{{ }} statement.",
181 |     "body": "{{ $1 \\}\\}"
182 |   },
183 |   "{!": {
184 |     "prefix": "{!",
185 |     "description": "{!! !!} statement",
186 |     "body": "{!! $1 !!\\}"
187 |   }
188 | }
189 | 


--------------------------------------------------------------------------------
/lua/user/keymaps.lua:
--------------------------------------------------------------------------------
  1 | -- Shorten function name
  2 | local keymap = vim.keymap.set
  3 | -- Silent keymap option
  4 | local opts = { noremap = true, silent = true }
  5 | 
  6 | local term_opts = { silent = true }
  7 | --Remap space as leader key
  8 | keymap("", "<Space>", "<Nop>", opts)
  9 | vim.g.mapleader = " "
 10 | -- Modes
 11 | --   normal_mode = "n",
 12 | --   insert_mode = "i",
 13 | --   visual_mode = "v",
 14 | --   visual_block_mode = "x",
 15 | --   term_mode = "t",
 16 | --   command_mode = "c",
 17 | 
 18 | -- Normal --
 19 | -- Better window navigation
 20 | keymap("n", "<C-h>", "<C-w>h", opts)
 21 | keymap("n", "<C-j>", "<C-w>j", opts)
 22 | keymap("n", "<C-k>", "<C-w>k", opts)
 23 | keymap("n", "<C-l>", "<C-w>l", opts)
 24 | 
 25 | --Spliting window
 26 | keymap("n", "<C-s>", ":vsplit<CR>gd", opts)
 27 | 
 28 | -- for emoji
 29 | vim.keymap.set("n", "<Leader><Leader>i", "<cmd>IconPickerNormal<cr>", opts)
 30 | 
 31 | 
 32 | -- Resize with arrows
 33 | keymap("n", "<C-Up>", ":resize +2<CR>", opts)
 34 | keymap("n", "<C-Down>", ":resize -2<CR>", opts)
 35 | keymap("n", "<C-Left>", ":vertical resize +2<CR>", opts)
 36 | keymap("n", "<C-Right>", ":vertical resize -2<CR>", opts)
 37 | 
 38 | -- Navigate buffers
 39 | keymap("n", "<S-l>", ":bnext<CR>", opts)
 40 | keymap("n", "<S-h>", ":bprevious<CR>", opts)
 41 | 
 42 | -- Clear highlights
 43 | keymap("n", "<leader>h", "<cmd>nohlsearch<CR>", opts)
 44 | 
 45 | -- Close buffers
 46 | keymap("n", "<S-q>", "<cmd>Bdelete!<CR>", opts)
 47 | -- keymap("n", ":wq", "<cmd>:w | Bdelete!<CR>", opts)
 48 | keymap("n", "<C-z>", "u", opts)
 49 | 
 50 | -- Better paste
 51 | keymap("v", "p", '"_dP', opts)
 52 | 
 53 | -- Insert --
 54 | -- Press jk fast to enter
 55 | keymap("i", "jk", "<ESC>", opts)
 56 | 
 57 | -- Visual --
 58 | -- Stay in indent mode
 59 | keymap("v", "<", "<gv", opts)
 60 | keymap("v", ">", ">gv", opts)
 61 | 
 62 | keymap("v", "V", ":m '>+1<CR>gv=gv", opts)
 63 | keymap("v", "K", ":m '<-2<CR>gv=gv", opts)
 64 | 
 65 | -- Visual Block Move text Up down
 66 | keymap("v", "<A-j>", ":m .+1<CR>==", opts)
 67 | keymap("v", "<A-k>", ":m .-2<CR>==", opts)
 68 | keymap("v", "p", '"_dP', opts)
 69 | 
 70 | -- Terminal
 71 | keymap("n", "<Ctrl-Shift-t>", ":FloatermNew", opts)
 72 | keymap("n", "<Ctrl-Shift-x", ":FloatermToggle!", opts)
 73 | 
 74 | -- Better terminal navigation
 75 | keymap("t", "<C-h>", "<C-\\><C-N><C-w>h", term_opts)
 76 | keymap("t", "<C-j>", "<C-\\><C-N><C-w>j", term_opts)
 77 | keymap("t", "<C-k>", "<C-\\><C-N><C-w>k", term_opts)
 78 | keymap("t", "<C-l>", "<C-\\><C-N><C-w>l", term_opts)
 79 | 
 80 | -- Old Files
 81 | keymap("n", "<leader>Fo", ":Telescope oldfiles<cr>", opts)
 82 | 
 83 | -- Plugins --
 84 | 
 85 | -- UndoTree
 86 | keymap("n", "<leader>u", vim.cmd.UndotreeToggle)
 87 | 
 88 | -- Telescope
 89 | --keymap("n", "<leader>ff", ":Telescope find_files<CR>", opts)
 90 | --keymap("n", "<leader>ft", ":Telescope live_grep<CR>", opts)
 91 | --keymap("n", "<leader>fp", ":Telescope projects<CR>", opts)
 92 | --keymap("n", "<leader>fb", ":Telescope buffers<CR>", opts)
 93 | 
 94 | -- Git
 95 | keymap("n", "<leader>gg", "<cmd>lua _LAZYGIT_TOGGLE()<CR>", opts)
 96 | 
 97 | -- Search
 98 | keymap("n", "n", "nzzzv")
 99 | keymap("n", "N", "Nzzzv")
100 | 
101 | -- Comment
102 | keymap("n", "<leader>/", "<cmd>lua require('Comment.api').toggle_current_linewise()<CR>", opts)
103 | keymap("x", "<leader>/", '<ESC><CMD>lua require("Comment.api").toggle_linewise_op(vim.fn.visualmode())<CR>')
104 | 
105 | -- Go to preview Keymaps
106 | keymap("n", "gpd", "<cmd>lua require('goto-preview').goto_preview_definition()<CR>", { noremap = true })
107 | keymap("n", "gpt", "<cmd>lua require('goto-preview').goto_preview_type_definition()<CR>", opts)
108 | keymap("n", "gpi", "lua require('goto-preview').goto_preview_implementation()", opts)
109 | keymap("n", "gP", "lua require('goto-preview').close_all_win()", opts)
110 | keymap("n", "gpr", "<cmd>lua require('goto-preview').goto_preview_references()", opts)
111 | 
112 | -- Codeium Insert suggestion
113 | -- keymap("i", "<M-i>", function()
114 | -- 	return vim.fn["codeium#Accept"]()
115 | -- end, { expr = true })
116 | 
117 | -- DAP
118 | -- keymap("n", "<leader>db", "<cmd>lua require'dap'.toggle_breakpoint()<cr>", opts)
119 | -- keymap("n", "<leader>dc", "<cmd>lua require'dap'.continue()<cr>", opts)
120 | -- keymap("n", "<leader>di", "<cmd>lua require'dap'.step_into()<cr>", opts)
121 | -- keymap("n", "<leader>do", "<cmd>lua require'dap'.step_over()<cr>", opts)
122 | -- keymap("n", "<leader>dO", "<cmd>lua require'dap'.step_out()<cr>", opts)
123 | -- keymap("n", "<leader>dr", "<cmd>lua require'dap'.repl.toggle()<cr>", opts)
124 | -- keymap("n", "<leader>dl", "<cmd>lua require'dap'.run_last()<cr>", opts)
125 | -- keymap("n", "<leader>du", "<cmd>lua require'dapui'.toggle()<cr>", opts)
126 | -- keymap("n", "<leader>dt", "<cmd>lua require'dap'.terminate()<cr>", opts)
127 | 


--------------------------------------------------------------------------------
/cool_snippets/jinja2.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "block": {
  3 |     "prefix": "block",
  4 |     "description": "block",
  5 |     "body": [
  6 |       "{% block ${1:name} %\\}",
  7 |       "\t\t$2",
  8 |       "{% endblock $1 %\\}"
  9 |     ],
 10 |     "luasnip": {
 11 |       "priority": -50
 12 |     }
 13 |   },
 14 |   "{{": {
 15 |     "prefix": "{{",
 16 |     "description": "variable",
 17 |     "body": "{{ $1 \\}\\}"
 18 |   },
 19 |   "{#": {
 20 |     "prefix": "{#",
 21 |     "description": "comment",
 22 |     "body": "{# $1 #\\}"
 23 |   },
 24 |   "#": {
 25 |     "prefix": "#",
 26 |     "description": "comment",
 27 |     "body": "{# $1 #\\}"
 28 |   },
 29 |   "raw": {
 30 |     "prefix": "raw",
 31 |     "description": "escaped block",
 32 |     "body": [
 33 |       "{% raw %\\}",
 34 |       "\t\t$1",
 35 |       "{% endraw %\\}"
 36 |     ]
 37 |   },
 38 |   "extends": {
 39 |     "prefix": "extends",
 40 |     "description": "extends",
 41 |     "body": "{% extends \"${1:template}\" %\\}"
 42 |   },
 43 |   "include": {
 44 |     "prefix": "include",
 45 |     "description": "include",
 46 |     "body": "{% include \"${1:template}\" %\\}"
 47 |   },
 48 |   "import": {
 49 |     "prefix": "import",
 50 |     "description": "import",
 51 |     "body": "{% import \"${1:template}\" %\\}"
 52 |   },
 53 |   "from": {
 54 |     "prefix": "from",
 55 |     "description": "from/import/as",
 56 |     "body": "{% from \"${1:template}\" import ${2:name}${3: as ${4:$2}} %\\}"
 57 |   },
 58 |   "filter": {
 59 |     "prefix": "filter",
 60 |     "description": "filter",
 61 |     "body": [
 62 |       "{% filter ${1:filter} %\\}",
 63 |       "\t$2",
 64 |       "{% endfilter %\\}"
 65 |     ]
 66 |   },
 67 |   "for": {
 68 |     "prefix": "for",
 69 |     "description": "for/else",
 70 |     "body": [
 71 |       "{% for ${1:item} in ${2:sequence} %\\}",
 72 |       "\t$3",
 73 |       "{% else %\\}",
 74 |       "\t$4",
 75 |       "{% endfor %\\}"
 76 |     ]
 77 |   },
 78 |   "if": {
 79 |     "prefix": "if",
 80 |     "description": "if/elif/else",
 81 |     "body": [
 82 |       "{% if ${1:expr} %\\}",
 83 |       "\t$2",
 84 |       "{% elif %\\}",
 85 |       "\t$3",
 86 |       "{% else %\\}",
 87 |       "\t$4",
 88 |       "{% endif %\\}"
 89 |     ]
 90 |   },
 91 |   "macro": {
 92 |     "prefix": "macro",
 93 |     "description": "macro",
 94 |     "body": [
 95 |       "{% macro ${1:name}(${2:args}) %\\}",
 96 |       "\t$3",
 97 |       "{% endmacro %\\}"
 98 |     ]
 99 |   },
100 |   "call": {
101 |     "prefix": "call",
102 |     "description": "call",
103 |     "body": [
104 |       "{% call ${1:name}(${2:args}) %\\}",
105 |       "\t$3",
106 |       "{% endcall %\\}"
107 |     ]
108 |   },
109 |   "set": {
110 |     "prefix": "set",
111 |     "description": "set",
112 |     "body": "{% set ${1:name} = ${2:'value'} %\\}"
113 |   },
114 |   "trans": {
115 |     "prefix": "trans",
116 |     "description": "translation",
117 |     "body": [
118 |       "{% trans %\\}",
119 |       "\t$1",
120 |       "{% endtrans %\\}"
121 |     ]
122 |   },
123 |   "with": {
124 |     "prefix": "with",
125 |     "description": "with",
126 |     "body": [
127 |       "{% with %\\}",
128 |       "\t$1",
129 |       "{% endwith %\\}"
130 |     ]
131 |   },
132 |   "autoescape": {
133 |     "prefix": "autoescape",
134 |     "description": "autoescape",
135 |     "body": [
136 |       "{% autoescape ${1:true} %\\}",
137 |       "\t$2",
138 |       "{% endautoescape %\\}"
139 |     ]
140 |   },
141 |   "batch": {
142 |     "prefix": "batch",
143 |     "description": "batch items",
144 |     "body": "batch(linecount=$1, fill_with=${2:None})"
145 |   },
146 |   "dictsort": {
147 |     "prefix": "dictsort",
148 |     "description": "sort and yield (key, value) pairs",
149 |     "body": "dictsort(case_sensitive=${1:False}, by=${2:'key'})"
150 |   },
151 |   "round": {
152 |     "prefix": "round",
153 |     "description": "round number",
154 |     "body": "round(precision=${1:0}, method=${2:'common|ceil|floor'})"
155 |   },
156 |   "urlize": {
157 |     "prefix": "urlize",
158 |     "description": "convert plain-text url to <a/>",
159 |     "body": "urlize(trim_url_limit=${1:None}, nofollow=${2:False})"
160 |   },
161 |   "wordwrap": {
162 |     "prefix": "wordwrap",
163 |     "description": "wordwrap",
164 |     "body": "wordwrap(width=${1:79}, break_long_words=${2:True})"
165 |   },
166 |   "truncate": {
167 |     "prefix": "truncate",
168 |     "description": "truncate",
169 |     "body": "truncate(lenght=${1:79}, killwords=${2:False}, end=${3:'...''})"
170 |   },
171 |   "sum": {
172 |     "prefix": "sum",
173 |     "description": "sum of sequence of numbers + start",
174 |     "body": "sum(attribute=${1:None}, start=${2:0})"
175 |   },
176 |   "sort": {
177 |     "prefix": "sort",
178 |     "description": "sort an iterable",
179 |     "body": "sort(reverse=${1:False}, case_sensitive=${2:False}, attribute=${3:None})"
180 |   },
181 |   "indent": {
182 |     "prefix": "indent",
183 |     "description": "indent",
184 |     "body": "indent(width=${1:4}, indentfirst=${2:False})"
185 |   }
186 | }
187 | 


--------------------------------------------------------------------------------
/cool_snippets/java.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "sleep": {
  3 |     "prefix": "sleep",
  4 |     "description": "try sleep catch",
  5 |     "body": [
  6 |       "try {",
  7 |       "\tThread.sleep(${1:1000});",
  8 |       "\\} catch (InterruptedException e){",
  9 |       "\te.printStackTrace();",
 10 |       "\\}"
 11 |     ],
 12 |     "luasnip": {
 13 |       "priority": -50
 14 |     }
 15 |   },
 16 |   "ab": {
 17 |     "prefix": "ab",
 18 |     "description": "abstract",
 19 |     "body": "abstract $0"
 20 |   },
 21 |   "at": {
 22 |     "prefix": "at",
 23 |     "description": "assert true",
 24 |     "body": "assertTrue(${1:actual});"
 25 |   },
 26 |   "af": {
 27 |     "prefix": "af",
 28 |     "description": "assert false",
 29 |     "body": "assertFalse(${1:actual});"
 30 |   },
 31 |   "ae": {
 32 |     "prefix": "ae",
 33 |     "description": "assert equals",
 34 |     "body": "assertEquals(${1:expected}, ${2:actual});"
 35 |   },
 36 |   "br": {
 37 |     "prefix": "br",
 38 |     "description": "break",
 39 |     "body": [
 40 |       "break;",
 41 |       ""
 42 |     ]
 43 |   },
 44 |   "cs": {
 45 |     "prefix": "cs",
 46 |     "description": "case",
 47 |     "body": [
 48 |       "case $1:",
 49 |       "\t$2",
 50 |       "$0"
 51 |     ]
 52 |   },
 53 |   "cos": {
 54 |     "prefix": "cos",
 55 |     "description": "constant string",
 56 |     "body": "public static final String ${1:var} = \"$2\";$0"
 57 |   },
 58 |   "co": {
 59 |     "prefix": "co",
 60 |     "description": "constant",
 61 |     "body": "public static final ${1:String} ${2:var} = $3;$0"
 62 |   },
 63 |   "de": {
 64 |     "prefix": "de",
 65 |     "description": "default",
 66 |     "body": [
 67 |       "default:",
 68 |       "\t$0"
 69 |     ]
 70 |   },
 71 |   "fi": {
 72 |     "prefix": "fi",
 73 |     "description": "final",
 74 |     "body": "final $0"
 75 |   },
 76 |   "imt": {
 77 |     "prefix": "imt",
 78 |     "description": "import junit_framework_TestCase;",
 79 |     "body": [
 80 |       "import junit.framework.TestCase;",
 81 |       "$0"
 82 |     ]
 83 |   },
 84 |   "im": {
 85 |     "prefix": "im",
 86 |     "description": "import",
 87 |     "body": "import ${1:java}.${2:util}.$0;"
 88 |   },
 89 |   "cc": {
 90 |     "prefix": "cc",
 91 |     "description": "constructor call or setter body",
 92 |     "body": "this.${1:var} = $1;"
 93 |   },
 94 |   "list": {
 95 |     "prefix": "list",
 96 |     "description": "Collections List",
 97 |     "body": "List<${1:String}> ${2:list} = new ${3:Array}List<$1>();"
 98 |   },
 99 |   "map": {
100 |     "prefix": "map",
101 |     "description": "Collections Map",
102 |     "body": "Map<${1:String}, ${2:String}> ${3:map} = new ${4:Hash}Map<$1, $2>();"
103 |   },
104 |   "set": {
105 |     "prefix": "set",
106 |     "description": "Collections Set",
107 |     "body": "Set<${1:String}> ${2:set} = new ${3:Hash}Set<$1>();"
108 |   },
109 |   "j.b": {
110 |     "prefix": "j.b",
111 |     "description": "java_beans_",
112 |     "body": "java.beans."
113 |   },
114 |   "j.i": {
115 |     "prefix": "j.i",
116 |     "description": "java_io",
117 |     "body": "java.io."
118 |   },
119 |   "j.m": {
120 |     "prefix": "j.m",
121 |     "description": "java_math",
122 |     "body": "java.math."
123 |   },
124 |   "j.n": {
125 |     "prefix": "j.n",
126 |     "description": "java_net_",
127 |     "body": "java.net."
128 |   },
129 |   "j.u": {
130 |     "prefix": "j.u",
131 |     "description": "java_util_",
132 |     "body": "java.util."
133 |   },
134 |   "try": {
135 |     "prefix": "try",
136 |     "description": "try/catch",
137 |     "body": [
138 |       "try {",
139 |       "\t$1$TM_SELECTED_TEXT",
140 |       "\\} catch(${2:Exception} ${3:e}){",
141 |       "\t${4:e.printStackTrace();}",
142 |       "\\}"
143 |     ]
144 |   },
145 |   "mt": {
146 |     "prefix": "mt",
147 |     "description": "method throws",
148 |     "body": [
149 |       "${1:private} ${2:void} ${3:method}($4) ${5:throws $6 }{",
150 |       "\t$0",
151 |       "\\}"
152 |     ]
153 |   },
154 |   "m": {
155 |     "prefix": "m",
156 |     "description": "method",
157 |     "body": [
158 |       "${1:private} ${2:void} ${3:method}($4) {",
159 |       "\t$0",
160 |       "\\}"
161 |     ]
162 |   },
163 |   "pa": {
164 |     "prefix": "pa",
165 |     "description": "package",
166 |     "body": "package $0"
167 |   },
168 |   "p": {
169 |     "prefix": "p",
170 |     "description": "print",
171 |     "body": "System.out.print($1);$0"
172 |   },
173 |   "pl": {
174 |     "prefix": "pl",
175 |     "description": "println",
176 |     "body": "System.out.println($1);$0"
177 |   },
178 |   "pr": {
179 |     "prefix": "pr",
180 |     "description": "private",
181 |     "body": "private $0"
182 |   },
183 |   "po": {
184 |     "prefix": "po",
185 |     "description": "protected",
186 |     "body": "protected $0"
187 |   },
188 |   "pu": {
189 |     "prefix": "pu",
190 |     "description": "public",
191 |     "body": "public $0"
192 |   },
193 |   "re": {
194 |     "prefix": "re",
195 |     "description": "return",
196 |     "body": "return $0"
197 |   },
198 |   "st": {
199 |     "prefix": "st",
200 |     "description": "static",
201 |     "body": "static $0"
202 |   },
203 |   "sy": {
204 |     "prefix": "sy",
205 |     "description": "synchronized",
206 |     "body": "synchronized $0"
207 |   },
208 |   "th": {
209 |     "prefix": "th",
210 |     "description": "throw",
211 |     "body": "throw new $0"
212 |   }
213 | }
214 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # A Basic Stable IDE config for Neovim
  2 | 
  3 | ```sh
  4 | git clone https://github.com/neovim/neovim.git
  5 | cd neovim
  6 | git checkout release-0.8
  7 | make CMAKE_BUILD_TYPE=Release
  8 | sudo make install
  9 | ```
 10 | 
 11 | ## ⚠️ ⚠️  Run these commands first ⚠️ ⚠️
 12 | 
 13 | #### For Ubuntu
 14 | 
 15 | ```sh
 16 | sudo apt update && sudo apt upgrade && sudo apt install git ripgrep xsel wl-clipboard cargo clang-format python3-pip npm
 17 | sudo npm install -g neovim && sudo pip install black pynvim && sudo cargo install stylua
 18 | ```
 19 | 
 20 | ##### For lazygit (Ubuntu)
 21 | ```sh
 22 | LAZYGIT_VERSION=$(curl -s "https://api.github.com/repos/jesseduffield/lazygit/releases/latest" | grep -Po '"tag_name": "v\K[^"]*')
 23 | curl -Lo lazygit.tar.gz "https://github.com/jesseduffield/lazygit/releases/latest/download/lazygit_${LAZYGIT_VERSION}_Linux_x86_64.tar.gz"
 24 | tar xf lazygit.tar.gz lazygit
 25 | sudo install lazygit /usr/local/bin
 26 | ```
 27 | 
 28 | 
 29 | ##### For lazygit (Fedora)
 30 | ```sh
 31 | sudo dnf copr enable atim/lazygit -y
 32 | sudo dnf install lazygit
 33 | ```
 34 | 
 35 | ##### Nodejs for specific distros
 36 | 
 37 | - [Here](https://github.com/nodesource/distributions)
 38 | 
 39 | 
 40 | Make sure to remove or move your current `nvim` directories: ```~/.config/nvim``` ```~/.local/share/nvim```
 41 | 
 42 | ```sh
 43 | git clone https://github.com/PiyushDuggal-source/neovim ~/.config/nvim
 44 | ```
 45 | 
 46 | 
 47 | Run `nvim` and wait for the plugins to be installed
 48 | 
 49 | **NOTE** (You will notice treesitter pulling in a bunch of parsers the next time you open Neovim)
 50 | 
 51 | ## Get health
 52 | 
 53 | Open `nvim` and enter the following:
 54 | 
 55 | ```
 56 | :checkhealth
 57 | ```
 58 | 
 59 | check the report and download required packages.
 60 | 
 61 | You'll probably notice you don't have support for copy/paste also that python and node haven't been setup
 62 | 
 63 | So let's fix that
 64 | 
 65 | First we'll fix copy/paste
 66 | 
 67 | - On mac `pbcopy` should be builtin
 68 | 
 69 | ---
 70 | 
 71 | **NOTE** make sure you have [node](https://nodejs.org/en/) installed, I recommend a node manager like [fnm](https://github.com/Schniz/fnm).
 72 | 
 73 | ## Fonts
 74 | 
 75 | I recommend using the following repo to get a "Nerd Font" (Font that supports icons)
 76 | 
 77 | [getnf](https://github.com/ronniedroid/getnf)
 78 | 
 79 | ## Configuration
 80 | 
 81 | ### LSP
 82 | 
 83 | To add a new LSP
 84 | 
 85 | First Enter:
 86 | 
 87 | ```
 88 | :LspInstallInfo
 89 | ```
 90 | 
 91 | and press `i` on the Language Server you wish to install
 92 | 
 93 | Next you will need to add the server to this list: [servers](https://github.com/LunarVim/nvim-basic-ide/blob/8b9ec3bffe8c8577042baf07c75408532a733fea/lua/user/lsp/lsp-installer.lua#L6)
 94 | 
 95 | ### Formatters and linters
 96 | 
 97 | Make sure the formatter or linter is installed and add it to this setup function: [null-ls](https://github.com/LunarVim/nvim-basic-ide/blob/8b9ec3bffe8c8577042baf07c75408532a733fea/lua/user/lsp/null-ls.lua#L13)
 98 | 
 99 | ## Plugins
100 | 
101 | - [packer](https://github.com/wbthomason/packer.nvim)
102 | - [plenary](https://github.com/nvim-lua/plenary.nvim)
103 | - [nvim-autopairs](https://github.com/windwp/nvim-autopairs)
104 | - [Comment.nvim](https://github.com/numToStr/Comment.nvim)
105 | - [nvim-ts-context-commentstring](https://github.com/JoosepAlviste/nvim-ts-context-commentstring)
106 | - [nvim-web-devicons](https://github.com/kyazdani42/nvim-web-devicons)
107 | - [nvim-tree.lua](https://github.com/kyazdani42/nvim-tree.lua)
108 | - [bufferline.nvim](https://github.com/akinsho/bufferline.nvim)
109 | - [vim-bbye](https://github.com/moll/vim-bbye)
110 | - [lualine.nvim](https://github.com/nvim-lualine/lualine.nvim)
111 | - [toggleterm.nvim](https://github.com/akinsho/toggleterm.nvim)
112 | - [project.nvim](https://github.com/ahmedkhalf/project.nvim)
113 | - [impatient.nvim](https://github.com/lewis6991/impatient.nvim)
114 | - [indent-blankline.nvim](https://github.com/lukas-reineke/indent-blankline.nvim)
115 | - [alpha-nvim](https://github.com/goolord/alpha-nvim)
116 | - [tokyonight.nvim](https://github.com/folke/tokyonight.nvim)
117 | - [darkplus.nvim](https://github.com/LunarVim/darkplus.nvim)
118 | - [nvim-cmp](https://github.com/hrsh7th/nvim-cmp)
119 | - [cmp-buffer](https://github.com/hrsh7th/cmp-buffer)
120 | - [cmp-path](https://github.com/hrsh7th/cmp-path)
121 | - [cmp_luasnip](https://github.com/saadparwaiz1/cmp_luasnip)
122 | - [cmp-nvim-lsp](https://github.com/hrsh7th/cmp-nvim-lsp)
123 | - [cmp-nvim-lua](https://github.com/hrsh7th/cmp-nvim-lua)
124 | - [LuaSnip](https://github.com/L3MON4D3/LuaSnip)
125 | - [friendly-snippets](https://github.com/rafamadriz/friendly-snippets)
126 | - [mason.nvim](https://github.com/williamboman/mason.nvim)
127 | - [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig)
128 | - [mason-lspconfig.nvim](https://github.com/williamboman/mason-lspconfig.nvim)
129 | - [null-ls.nvim](https://github.com/jose-elias-alvarez/null-ls.nvim)
130 | - [vim-illuminate](https://github.com/RRethy/vim-illuminate)
131 | - [telescope.nvim](https://github.com/nvim-telescope/telescope.nvim)
132 | - [nvim-treesitter](https://github.com/nvim-treesitter/nvim-treesitter)
133 | - [gitsigns.nvim](https://github.com/lewis6991/gitsigns.nvim)
134 | - [nvim-dap](https://github.com/mfussenegger/nvim-dap)
135 | - [nvim-dap-ui](https://github.com/rcarriga/nvim-dap-ui)
136 | - [DAPInstall.nvim](https://github.com/ravenxrz/DAPInstall.nvim)
137 | - etc.
138 | 
139 | ---
140 | 
141 | > If debugging is the process of removing bug, then programming must be the process of putting them in.
142 | 
143 | \- Edsger W. Dijkstra
144 | 


--------------------------------------------------------------------------------
/cool_snippets/r.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "#!": {
  3 |     "prefix": "#!",
  4 |     "description": "#!/usr/bin/env Rscript",
  5 |     "body": [
  6 |       "#!/usr/bin/env Rscript",
  7 |       "$0"
  8 |     ],
  9 |     "luasnip": {
 10 |       "priority": -20
 11 |     }
 12 |   },
 13 |   "lib": {
 14 |     "prefix": "lib",
 15 |     "description": "Import a library",
 16 |     "body": "library('${0:${TM_SELECTED_TEXT:package}}')"
 17 |   },
 18 |   "req": {
 19 |     "prefix": "req",
 20 |     "description": "Require a file",
 21 |     "body": "require('${0:${TM_SELECTED_TEXT:package}}')"
 22 |   },
 23 |   "source": {
 24 |     "prefix": "source",
 25 |     "description": "Source a file",
 26 |     "body": "source('${0:${TM_SELECTED_TEXT:file}}')"
 27 |   },
 28 |   "if": {
 29 |     "prefix": "if",
 30 |     "description": "If statement",
 31 |     "body": [
 32 |       "if ($1) {",
 33 |       "\t${0:$TM_SELECTED_TEXT}",
 34 |       "\\}"
 35 |     ]
 36 |   },
 37 |   "eif": {
 38 |     "prefix": "eif",
 39 |     "description": "Else-If statement",
 40 |     "body": [
 41 |       "else if ($1) {",
 42 |       "\t${0:$TM_SELECTED_TEXT}",
 43 |       "\\}"
 44 |     ]
 45 |   },
 46 |   "el": {
 47 |     "prefix": "el",
 48 |     "description": "Else statement",
 49 |     "body": [
 50 |       "else {",
 51 |       "\t${0:$TM_SELECTED_TEXT}",
 52 |       "\\}"
 53 |     ]
 54 |   },
 55 |   "ife": {
 56 |     "prefix": "ife",
 57 |     "description": "if .. else",
 58 |     "body": [
 59 |       "if ($1) {",
 60 |       "\t${2:$TM_SELECTED_TEXT}",
 61 |       "\\} else {",
 62 |       "\t$0",
 63 |       "\\}"
 64 |     ]
 65 |   },
 66 |   "wh": {
 67 |     "prefix": "wh",
 68 |     "description": "while loop",
 69 |     "body": [
 70 |       "while($1) {",
 71 |       "\t${0:$TM_SELECTED_TEXT}",
 72 |       "\\}"
 73 |     ]
 74 |   },
 75 |   "for": {
 76 |     "prefix": "for",
 77 |     "description": "for loop",
 78 |     "body": [
 79 |       "for (${1:item} in ${2:list}) {",
 80 |       "\t${0:$TM_SELECTED_TEXT}",
 81 |       "\\}"
 82 |     ]
 83 |   },
 84 |   "fun": {
 85 |     "prefix": "fun",
 86 |     "description": "Function definition",
 87 |     "body": [
 88 |       "${1:name} <- function ($2) {",
 89 |       "\t${0:$TM_SELECTED_TEXT}",
 90 |       "\\}"
 91 |     ]
 92 |   },
 93 |   "ret": {
 94 |     "prefix": "ret",
 95 |     "description": "Return call",
 96 |     "body": "return(${0:$TM_SELECTED_TEXT})"
 97 |   },
 98 |   "df": {
 99 |     "prefix": "df",
100 |     "description": "Data frame",
101 |     "body": "${1:name}[${2:rows}, ${0:cols}]"
102 |   },
103 |   "c": {
104 |     "prefix": "c",
105 |     "description": "c function",
106 |     "body": "c(${0:${TM_SELECTED_TEXT:items}})"
107 |   },
108 |   "li": {
109 |     "prefix": "li",
110 |     "description": "list function",
111 |     "body": "list(${0:${TM_SELECTED_TEXT:items}})"
112 |   },
113 |   "mat": {
114 |     "prefix": "mat",
115 |     "description": "matrix function",
116 |     "body": "matrix(${1:${TM_SELECTED_TEXT:data}}, nrow = ${2:rows}, ncol = ${0:cols})"
117 |   },
118 |   "apply": {
119 |     "prefix": "apply",
120 |     "description": "apply function",
121 |     "body": "apply(${1:${TM_SELECTED_TEXT:array}}, ${2:margin}, ${0:function})"
122 |   },
123 |   "lapply": {
124 |     "prefix": "lapply",
125 |     "description": "lapply function",
126 |     "body": "lapply(${1:${TM_SELECTED_TEXT:list}}, ${0:function})"
127 |   },
128 |   "sapply": {
129 |     "prefix": "sapply",
130 |     "description": "sapply function",
131 |     "body": "sapply(${1:${TM_SELECTED_TEXT:list}}, ${0:function})"
132 |   },
133 |   "vapply": {
134 |     "prefix": "vapply",
135 |     "description": "vapply function",
136 |     "body": "vapply(${1:${TM_SELECTED_TEXT:list}}, ${2:function}, ${0:type})"
137 |   },
138 |   "mapply": {
139 |     "prefix": "mapply",
140 |     "description": "mapply function",
141 |     "body": "mapply(${1:${TM_SELECTED_TEXT:function}}, ${0:...})"
142 |   },
143 |   "tapply": {
144 |     "prefix": "tapply",
145 |     "description": "tapply function",
146 |     "body": "tapply(${1:${TM_SELECTED_TEXT:vector}}, ${2:index}, ${0:function})"
147 |   },
148 |   "rapply": {
149 |     "prefix": "rapply",
150 |     "description": "rapply function",
151 |     "body": "rapply(${1:${TM_SELECTED_TEXT:list}}, ${0:function})"
152 |   },
153 |   "pl": {
154 |     "prefix": "pl",
155 |     "description": "Plot function",
156 |     "body": "plot(${1:${TM_SELECTED_TEXT:x}}, ${0:y})"
157 |   },
158 |   "ggp": {
159 |     "prefix": "ggp",
160 |     "description": "ggplot2 plot",
161 |     "body": "ggplot(${1:${TM_SELECTED_TEXT:data}}, aes(${0:aesthetics}))"
162 |   },
163 |   "fis": {
164 |     "prefix": "fis",
165 |     "description": "Fisher test",
166 |     "body": "fisher.test(${1:x}, ${0:y})"
167 |   },
168 |   "chi": {
169 |     "prefix": "chi",
170 |     "description": "Chi Squared test",
171 |     "body": "chisq.test(${1:x}, ${0:y})"
172 |   },
173 |   "tt": {
174 |     "prefix": "tt",
175 |     "description": "t-test",
176 |     "body": "t.test(${1:x}, ${0:y})"
177 |   },
178 |   "wil": {
179 |     "prefix": "wil",
180 |     "description": "Wilcox test",
181 |     "body": "wilcox.test(${1:x}, ${0:y})"
182 |   },
183 |   "cor": {
184 |     "prefix": "cor",
185 |     "description": "Correlation test",
186 |     "body": "cor.test(${1:x}, ${0:y})"
187 |   },
188 |   "fte": {
189 |     "prefix": "fte",
190 |     "description": "FTE test",
191 |     "body": "var.test(${1:x}, ${0:y})"
192 |   },
193 |   "kvt": {
194 |     "prefix": "kvt",
195 |     "description": "KV test",
196 |     "body": "kv.test(${1:x}, ${0:y})"
197 |   },
198 |   "vec": {
199 |     "prefix": "vec",
200 |     "body": "${1:var} <- c(\"${0:\\${VISUAL:/ /\",\"/g\\}}\")"
201 |   }
202 | }
203 | 


--------------------------------------------------------------------------------
/lua/user/lsp/settings/jsonls.lua:
--------------------------------------------------------------------------------
  1 | -- Find more schemas here: https://www.schemastore.org/json/
  2 | local schemas = {
  3 |   {
  4 |     description = "TypeScript compiler configuration file",
  5 |     fileMatch = {
  6 |       "tsconfig.json",
  7 |       "tsconfig.*.json",
  8 |     },
  9 |     url = "https://json.schemastore.org/tsconfig.json",
 10 |   },
 11 |   {
 12 |     description = "Lerna config",
 13 |     fileMatch = { "lerna.json" },
 14 |     url = "https://json.schemastore.org/lerna.json",
 15 |   },
 16 |   {
 17 |     description = "Babel configuration",
 18 |     fileMatch = {
 19 |       ".babelrc.json",
 20 |       ".babelrc",
 21 |       "babel.config.json",
 22 |     },
 23 |     url = "https://json.schemastore.org/babelrc.json",
 24 |   },
 25 |   {
 26 |     description = "ESLint config",
 27 |     fileMatch = {
 28 |       ".eslintrc.json",
 29 |       ".eslintrc",
 30 |     },
 31 |     url = "https://json.schemastore.org/eslintrc.json",
 32 |   },
 33 |   {
 34 |     description = "Bucklescript config",
 35 |     fileMatch = { "bsconfig.json" },
 36 |     url = "https://raw.githubusercontent.com/rescript-lang/rescript-compiler/8.2.0/docs/docson/build-schema.json",
 37 |   },
 38 |   {
 39 |     description = "Prettier config",
 40 |     fileMatch = {
 41 |       ".prettierrc",
 42 |       ".prettierrc.json",
 43 |       "prettier.config.json",
 44 |     },
 45 |     url = "https://json.schemastore.org/prettierrc",
 46 |   },
 47 |   {
 48 |     description = "Vercel Now config",
 49 |     fileMatch = { "now.json" },
 50 |     url = "https://json.schemastore.org/now",
 51 |   },
 52 |   {
 53 |     description = "Stylelint config",
 54 |     fileMatch = {
 55 |       ".stylelintrc",
 56 |       ".stylelintrc.json",
 57 |       "stylelint.config.json",
 58 |     },
 59 |     url = "https://json.schemastore.org/stylelintrc",
 60 |   },
 61 |   {
 62 |     description = "A JSON schema for the ASP.NET LaunchSettings.json files",
 63 |     fileMatch = { "launchsettings.json" },
 64 |     url = "https://json.schemastore.org/launchsettings.json",
 65 |   },
 66 |   {
 67 |     description = "Schema for CMake Presets",
 68 |     fileMatch = {
 69 |       "CMakePresets.json",
 70 |       "CMakeUserPresets.json",
 71 |     },
 72 |     url = "https://raw.githubusercontent.com/Kitware/CMake/master/Help/manual/presets/schema.json",
 73 |   },
 74 |   {
 75 |     description = "Configuration file as an alternative for configuring your repository in the settings page.",
 76 |     fileMatch = {
 77 |       ".codeclimate.json",
 78 |     },
 79 |     url = "https://json.schemastore.org/codeclimate.json",
 80 |   },
 81 |   {
 82 |     description = "LLVM compilation database",
 83 |     fileMatch = {
 84 |       "compile_commands.json",
 85 |     },
 86 |     url = "https://json.schemastore.org/compile-commands.json",
 87 |   },
 88 |   {
 89 |     description = "Config file for Command Task Runner",
 90 |     fileMatch = {
 91 |       "commands.json",
 92 |     },
 93 |     url = "https://json.schemastore.org/commands.json",
 94 |   },
 95 |   {
 96 |     description = "AWS CloudFormation provides a common language for you to describe and provision all the infrastructure resources in your cloud environment.",
 97 |     fileMatch = {
 98 |       "*.cf.json",
 99 |       "cloudformation.json",
100 |     },
101 |     url = "https://raw.githubusercontent.com/awslabs/goformation/v5.2.9/schema/cloudformation.schema.json",
102 |   },
103 |   {
104 |     description = "The AWS Serverless Application Model (AWS SAM, previously known as Project Flourish) extends AWS CloudFormation to provide a simplified way of defining the Amazon API Gateway APIs, AWS Lambda functions, and Amazon DynamoDB tables needed by your serverless application.",
105 |     fileMatch = {
106 |       "serverless.template",
107 |       "*.sam.json",
108 |       "sam.json",
109 |     },
110 |     url = "https://raw.githubusercontent.com/awslabs/goformation/v5.2.9/schema/sam.schema.json",
111 |   },
112 |   {
113 |     description = "Json schema for properties json file for a GitHub Workflow template",
114 |     fileMatch = {
115 |       ".github/workflow-templates/**.properties.json",
116 |     },
117 |     url = "https://json.schemastore.org/github-workflow-template-properties.json",
118 |   },
119 |   {
120 |     description = "golangci-lint configuration file",
121 |     fileMatch = {
122 |       ".golangci.toml",
123 |       ".golangci.json",
124 |     },
125 |     url = "https://json.schemastore.org/golangci-lint.json",
126 |   },
127 |   {
128 |     description = "JSON schema for the JSON Feed format",
129 |     fileMatch = {
130 |       "feed.json",
131 |     },
132 |     url = "https://json.schemastore.org/feed.json",
133 |     versions = {
134 |       ["1"] = "https://json.schemastore.org/feed-1.json",
135 |       ["1.1"] = "https://json.schemastore.org/feed.json",
136 |     },
137 |   },
138 |   {
139 |     description = "Packer template JSON configuration",
140 |     fileMatch = {
141 |       "packer.json",
142 |     },
143 |     url = "https://json.schemastore.org/packer.json",
144 |   },
145 |   {
146 |     description = "NPM configuration file",
147 |     fileMatch = {
148 |       "package.json",
149 |     },
150 |     url = "https://json.schemastore.org/package.json",
151 |   },
152 |   {
153 |     description = "JSON schema for Visual Studio component configuration files",
154 |     fileMatch = {
155 |       "*.vsconfig",
156 |     },
157 |     url = "https://json.schemastore.org/vsconfig.json",
158 |   },
159 |   {
160 |     description = "Resume json",
161 |     fileMatch = { "resume.json" },
162 |     url = "https://raw.githubusercontent.com/jsonresume/resume-schema/v1.0.0/schema.json",
163 |   },
164 | }
165 | 
166 | local opts = {
167 |   settings = {
168 |     json = {
169 |       schemas = schemas,
170 |     },
171 |   },
172 |   setup = {
173 |     commands = {
174 |       Format = {
175 |         function()
176 |           vim.lsp.buf.range_formatting({}, { 0, 0 }, { vim.fn.line "$", 0 })
177 |         end,
178 |       },
179 |     },
180 |   },
181 | }
182 | 
183 | return opts
184 | 


--------------------------------------------------------------------------------
/lua/user/lsp/lsp-installer.lua:
--------------------------------------------------------------------------------
  1 | -- local status_ok, lsp_installer = pcall(require, "nvim-lsp-installer")
  2 | -- if not status_ok then
  3 | --   return
  4 | -- end
  5 | -- -- local coq = require "coq"
  6 | --
  7 | -- -- Register a handler that will be called for all installed servers.
  8 | -- -- Alternatively, you may also register handlers on specific server instances instead (see example below).
  9 | -- lsp_installer.on_server_ready(function(server)
 10 | --   local opts = {
 11 | --     on_attach = require("user.lsp.handlers").on_attach,
 12 | --     capabilities = require("user.lsp.handlers").capabilities,
 13 | --   }
 14 | --
 15 | --   if server.name == "jsonls" then
 16 | --     local jsonls_opts = require("user.lsp.settings.jsonls")
 17 | --     opts = vim.tbl_deep_extend("force", jsonls_opts, opts)
 18 | --   end
 19 | --
 20 | --   if server.name == "sumneko_lua" then
 21 | --     local sumneko_opts = require("user.lsp.settings.sumneko_lua")
 22 | --     opts = vim.tbl_deep_extend("force", sumneko_opts, opts)
 23 | --   end
 24 | --
 25 | --   if server.name == "pyright" then
 26 | --     local pyright_opts = require("user.lsp.settings.pyright")
 27 | --     opts = vim.tbl_deep_extend("force", pyright_opts, opts)
 28 | --   end
 29 | --
 30 | --   -- This setup() function is exactly the same as lspconfig's setup function.
 31 | --   -- Refer to https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md
 32 | --   -- server:setup(coq.lsp_ensure_capabilities(opts))
 33 | --   server:setup(opts)
 34 | -- end)
 35 | 
 36 | -- local on_attach = require("user.lsp.handlers").on_attach
 37 | -- local capabilities = require("user.lsp.handlers").capabilities
 38 | 
 39 | require("user.lsp.handlers").setup()
 40 | -- local typescript_setup, typescript = pcall(require, "typescript")
 41 | -- if not typescript_setup then
 42 | -- 	return
 43 | -- end
 44 | 
 45 | -- local lspconfig = require("lspconfig")
 46 | -- local servers = {
 47 | -- 	"cssls",
 48 | -- 	-- "emmet_ls",
 49 | -- 	"clangd",
 50 | -- 	"lua_ls",
 51 | -- 	"eslint",
 52 | -- 	-- "gopls",
 53 | -- 	"pyright",
 54 | -- 	"html",
 55 | -- 	"bashls",
 56 | -- 	"cssmodules_ls",
 57 | -- 	"jsonls",
 58 | -- 	"gopls",
 59 | -- 	"volar",
 60 | -- 	"yamlls",
 61 | -- 	-- "vuels",
 62 | -- 	"tailwindcss",
 63 | -- 	"cssls",
 64 | -- 	-- "intelephense",
 65 | -- 	"phpactor",
 66 | -- 	-- "dockerls",
 67 | -- }
 68 | -- local lspInlays = { "tsserver" }
 69 | -- capabilities.textDocument.foldingRange = {
 70 | -- 	dynamicRegistration = false,
 71 | -- 	lineFoldingOnly = true,
 72 | -- }
 73 | -- for _, lsp in ipairs(servers) do
 74 | -- 	lspconfig[lsp].setup({
 75 | -- 		on_attach = on_attach,
 76 | -- 		capabilities = capabilities,
 77 | -- 		handlers = {
 78 | -- 			["textDocument/publishDiagnostics"] = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
 79 | -- 				-- Disable virtual_text
 80 | -- 				virtual_text = false,
 81 | -- 			}),
 82 | -- 		},
 83 | -- 		settings = {
 84 | -- 			Lua = {
 85 | -- 				diagnostics = {
 86 | -- 					-- Get the language server to recognize the `vim` global
 87 | -- 					globals = { "vim" },
 88 | -- 				},
 89 | -- 			},
 90 | -- 		},
 91 | -- 	})
 92 | -- end
 93 | --
 94 | -- lspconfig.volar.setup({
 95 | -- 	on_attach = on_attach,
 96 | -- 	capabilities = capabilities,
 97 | -- 	handlers = {
 98 | -- 		["textDocument/publishDiagnostics"] = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
 99 | -- 			-- Disable virtual_text
100 | -- 			virtual_text = false,
101 | -- 		}),
102 | -- 	},
103 | -- 	filetypes = { "php" },
104 | -- })
105 | -- lspconfig.pyright.setup({
106 | -- 	on_attach = on_attach,
107 | -- 	settings = {
108 | -- 		python = {
109 | -- 			analysis = {
110 | -- 				typeCheckingMode = "off",
111 | -- 			},
112 | -- 			files = {
113 | -- 				"python",
114 | -- 			},
115 | -- 		},
116 | -- 	},
117 | -- })
118 | --
119 | -- -- lspconfig.intelephense.setup {
120 | -- --
121 | -- --   on_attach = on_attach,
122 | -- --   capabilities = capabilities,
123 | -- --   handlers = {
124 | -- --     ["textDocument/publishDiagnostics"] = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
125 | -- --       -- Disable virtual_text
126 | -- --       virtual_text = false,
127 | -- --     }),
128 | -- --   },
129 | -- --   filetypes = { 'php' }
130 | -- -- }
131 | --
132 | -- for _, lsp in ipairs(lspInlays) do
133 | -- 	lspconfig[lsp].setup({
134 | -- 		on_attach = function(client, bufnr)
135 | -- 			on_attach(client, bufnr)
136 | --
137 | -- 			require("lsp-inlayhints").on_attach(client, bufnr)
138 | -- 		end,
139 | --
140 | -- 		handlers = {
141 | -- 			["textDocument/publishDiagnostics"] = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
142 | -- 				-- Disable virtual_text
143 | -- 				virtual_text = false,
144 | -- 			}),
145 | -- 		},
146 | -- 		capabilities = capabilities,
147 | -- 		settings = {
148 | -- 			typescript = {
149 | -- 				inlayHints = {
150 | -- 					includeInlayParameterNameHints = "all",
151 | -- 					includeInlayParameterNameHintsWhenArgumentMatchesName = false,
152 | -- 					includeInlayFunctionParameterTypeHints = true,
153 | -- 					includeInlayVariableTypeHints = true,
154 | -- 					includeInlayPropertyDeclarationTypeHints = true,
155 | -- 					includeInlayFunctionLikeReturnTypeHints = true,
156 | -- 					includeInlayEnumMemberValueHints = true,
157 | -- 				},
158 | -- 			},
159 | -- 			javascript = {
160 | -- 				inlayHints = {
161 | -- 					includeInlayParameterNameHints = "all",
162 | -- 					includeInlayParameterNameHintsWhenArgumentMatchesName = false,
163 | -- 					includeInlayFunctionParameterTypeHints = true,
164 | -- 					includeInlayVariableTypeHints = true,
165 | -- 					includeInlayPropertyDeclarationTypeHints = true,
166 | -- 					includeInlayFunctionLikeReturnTypeHints = true,
167 | -- 					includeInlayEnumMemberValueHints = true,
168 | -- 				},
169 | -- 			},
170 | -- 		},
171 | -- 	})
172 | -- end
173 | 
174 | -- lspconfig["emmet_ls"].setup({
175 | --   capabilities = capabilities,
176 | --   on_attach = on_attach,
177 | --   filetypes = { "html", "typescriptreact", "javascriptreact", "css", "sass", "scss", "less", "svelte" },
178 | -- })
179 | 


--------------------------------------------------------------------------------
/cool_snippets/ocaml.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "rs": {
  3 |     "prefix": "rs",
  4 |     "description": "raise",
  5 |     "body": "raise (${1:Not_found})",
  6 |     "luasnip": {
  7 |       "priority": -50
  8 |     }
  9 |   },
 10 |   "open": {
 11 |     "prefix": "open",
 12 |     "description": "open",
 13 |     "body": [
 14 |       "let open ${1:module} in",
 15 |       "${2:e}"
 16 |     ]
 17 |   },
 18 |   "try": {
 19 |     "prefix": "try",
 20 |     "description": "try",
 21 |     "body": [
 22 |       "try ${1:e}",
 23 |       "with ${2:Not_found} -> ${3:()}"
 24 |     ]
 25 |   },
 26 |   "ref": {
 27 |     "prefix": "ref",
 28 |     "description": "ref",
 29 |     "body": [
 30 |       "let ${1:name} = ref ${2:val} in",
 31 |       "${3:e}"
 32 |     ]
 33 |   },
 34 |   "matchl": {
 35 |     "prefix": "matchl",
 36 |     "description": "pattern match on a list",
 37 |     "body": [
 38 |       "match ${1:list} with",
 39 |       "| [] -> ${2:()}",
 40 |       "| x::xs -> ${3:()}"
 41 |     ]
 42 |   },
 43 |   "matcho": {
 44 |     "prefix": "matcho",
 45 |     "description": "pattern match on an option type",
 46 |     "body": [
 47 |       "match ${1:x} with",
 48 |       "| Some(${2:y}) -> ${3:()}",
 49 |       "| None -> ${4:()}"
 50 |     ]
 51 |   },
 52 |   "fun": {
 53 |     "prefix": "fun",
 54 |     "description": "anonymous function",
 55 |     "body": "(fun ${1:x} -> ${2:x})"
 56 |   },
 57 |   "cc": {
 58 |     "prefix": "cc",
 59 |     "description": "commment",
 60 |     "body": "(* ${1:comment} *)"
 61 |   },
 62 |   "let": {
 63 |     "prefix": "let",
 64 |     "description": "let .. in binding",
 65 |     "body": [
 66 |       "let ${1:x} = ${2:v} in",
 67 |       "${3:e}"
 68 |     ]
 69 |   },
 70 |   "lr": {
 71 |     "prefix": "lr",
 72 |     "description": "let rec",
 73 |     "body": [
 74 |       "let rec ${1:f} =",
 75 |       "\t${2:expr}"
 76 |     ]
 77 |   },
 78 |   "if": {
 79 |     "prefix": "if",
 80 |     "description": "if",
 81 |     "body": [
 82 |       "if ${1:(* condition *)} then",
 83 |       "\t${2:(* A *)}",
 84 |       "else",
 85 |       "\t${3:(* B *)}"
 86 |     ]
 87 |   },
 88 |   "If": {
 89 |     "prefix": "If",
 90 |     "description": "If",
 91 |     "body": [
 92 |       "if ${1:(* condition *)} then",
 93 |       "\t${2:(* A *)}"
 94 |     ]
 95 |   },
 96 |   "while": {
 97 |     "prefix": "while",
 98 |     "description": "while",
 99 |     "body": [
100 |       "while ${1:(* condition *)} do",
101 |       "\t${2:(* A *)}",
102 |       "done"
103 |     ]
104 |   },
105 |   "for": {
106 |     "prefix": "for",
107 |     "description": "for",
108 |     "body": [
109 |       "for ${1:i} = ${2:1} to ${3:10} do",
110 |       "\t${4:(* BODY *)}",
111 |       "done"
112 |     ]
113 |   },
114 |   "match": {
115 |     "prefix": "match",
116 |     "description": "match",
117 |     "body": [
118 |       "match ${1:(* e1 *)} with",
119 |       "| ${2:p} -> ${3:e2}"
120 |     ]
121 |   },
122 |   "Match": {
123 |     "prefix": "Match",
124 |     "description": "match",
125 |     "body": [
126 |       "match ${1:(* e1 *)} with",
127 |       "| ${2:p} -> ${3:e2}"
128 |     ]
129 |   },
130 |   "class": {
131 |     "prefix": "class",
132 |     "description": "class",
133 |     "body": [
134 |       "class ${1:name} = object",
135 |       "\t${2:methods}",
136 |       "end"
137 |     ]
138 |   },
139 |   "obj": {
140 |     "prefix": "obj",
141 |     "description": "obj",
142 |     "body": [
143 |       "object",
144 |       "\t${2:methods}",
145 |       "end"
146 |     ]
147 |   },
148 |   "Obj": {
149 |     "prefix": "Obj",
150 |     "description": "object",
151 |     "body": [
152 |       "object (self)",
153 |       "\t${2:methods}",
154 |       "end"
155 |     ]
156 |   },
157 |   "{{": {
158 |     "prefix": "{{",
159 |     "description": "object functional update",
160 |     "body": "{< ${1:x} = ${2:y} >\\}"
161 |   },
162 |   "beg": {
163 |     "prefix": "beg",
164 |     "description": "beg",
165 |     "body": [
166 |       "begin",
167 |       "\t${1:block}",
168 |       "end"
169 |     ]
170 |   },
171 |   "ml": {
172 |     "prefix": "ml",
173 |     "description": "module instantiantion with functor",
174 |     "body": "module ${1:Mod} = ${2:Functor}(${3:Arg})"
175 |   },
176 |   "mod": {
177 |     "prefix": "mod",
178 |     "description": "module - no signature",
179 |     "body": [
180 |       "module ${1:(* Name *)} = struct",
181 |       "\t${2:(* BODY *)}",
182 |       "end"
183 |     ]
184 |   },
185 |   "Mod": {
186 |     "prefix": "Mod",
187 |     "description": "module with signature",
188 |     "body": [
189 |       "module ${1:(* Name *)} : ${2:(* SIG *)} = struct",
190 |       "\t${3:(* BODY *)}",
191 |       "end"
192 |     ]
193 |   },
194 |   "sig": {
195 |     "prefix": "sig",
196 |     "description": "anonymous signature",
197 |     "body": [
198 |       "sig",
199 |       "\t${2:(* BODY *)}",
200 |       "end"
201 |     ]
202 |   },
203 |   "sigf": {
204 |     "prefix": "sigf",
205 |     "description": "functor signature or anonymous functor",
206 |     "body": "functor (${1:Arg} : ${2:ARG}) -> ${3:(* BODY *)}"
207 |   },
208 |   "func": {
209 |     "prefix": "func",
210 |     "description": "define functor - no signature",
211 |     "body": [
212 |       "module ${1:M} (${2:Arg} : ${3:ARG}) = struct",
213 |       "\t${4:(* BODY *)}",
214 |       "end"
215 |     ]
216 |   },
217 |   "Func": {
218 |     "prefix": "Func",
219 |     "description": "define functor - with signature",
220 |     "body": [
221 |       "module ${1:M} (${2:Arg} : ${3:ARG}) : ${4:SIG} = struct",
222 |       "\t${5:(* BODY *)}",
223 |       "end"
224 |     ]
225 |   },
226 |   "mot": {
227 |     "prefix": "mot",
228 |     "description": "Declare module signature",
229 |     "body": [
230 |       "module type ${1:(* Name *)} = sig",
231 |       "\t${2:(* BODY *)}",
232 |       "end"
233 |     ]
234 |   },
235 |   "module": {
236 |     "prefix": "module",
237 |     "description": "Module with anonymous signature",
238 |     "body": [
239 |       "module ${1:(* Name *)} : sig",
240 |       "\t${2:(* SIGNATURE *)}",
241 |       "end = struct",
242 |       "\t${3:(* BODY *)}",
243 |       "end"
244 |     ]
245 |   },
246 |   "oo": {
247 |     "prefix": "oo",
248 |     "description": "odoc",
249 |     "body": "(** ${1:odoc} *)"
250 |   },
251 |   "qt": {
252 |     "prefix": "qt",
253 |     "description": "inline qtest",
254 |     "body": [
255 |       "(*\\$T ${1:name}",
256 |       "\t${2:test}",
257 |       "*)"
258 |     ]
259 |   }
260 | }
261 | 


--------------------------------------------------------------------------------
/cool_snippets/coffee-jasmine.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "des": {
  3 |     "prefix": "des",
  4 |     "description": "Describe (coffee)",
  5 |     "body": [
  6 |       "describe '${1:description}', ->",
  7 |       "\t$0"
  8 |     ],
  9 |     "luasnip": {
 10 |       "priority": -49
 11 |     }
 12 |   },
 13 |   "it": {
 14 |     "prefix": "it",
 15 |     "description": "it (coffee)",
 16 |     "body": [
 17 |       "it '${1:description}', ->",
 18 |       "\t$0"
 19 |     ]
 20 |   },
 21 |   "bef": {
 22 |     "prefix": "bef",
 23 |     "description": "before each (coffee)",
 24 |     "body": [
 25 |       "beforeEach ->",
 26 |       "\t$0"
 27 |     ]
 28 |   },
 29 |   "aft": {
 30 |     "prefix": "aft",
 31 |     "description": "after each (coffee)",
 32 |     "body": [
 33 |       "afterEach ->",
 34 |       "\t$0"
 35 |     ]
 36 |   },
 37 |   "any": {
 38 |     "prefix": "any",
 39 |     "description": "any (coffee)",
 40 |     "body": "jasmine.any($1)"
 41 |   },
 42 |   "ru": {
 43 |     "prefix": "ru",
 44 |     "description": "runs (coffee)",
 45 |     "body": [
 46 |       "runs ->",
 47 |       "\t$0"
 48 |     ]
 49 |   },
 50 |   "wa": {
 51 |     "prefix": "wa",
 52 |     "description": "waits (coffee)",
 53 |     "body": "waits($1)"
 54 |   },
 55 |   "ex": {
 56 |     "prefix": "ex",
 57 |     "description": "expect (coffee)",
 58 |     "body": "expect(${1:target})$0"
 59 |   },
 60 |   "ee": {
 61 |     "prefix": "ee",
 62 |     "description": "expect to equal (coffee)",
 63 |     "body": "expect(${1:target}).toEqual(${2:value})"
 64 |   },
 65 |   "em": {
 66 |     "prefix": "em",
 67 |     "description": "expect to match (coffee)",
 68 |     "body": "expect(${1:target}).toMatch(${2:pattern})"
 69 |   },
 70 |   "eha": {
 71 |     "prefix": "eha",
 72 |     "description": "expect to have attribute (coffee)",
 73 |     "body": "expect(${1:target}).toHaveAttr('${2:attr}'${3:, '${4:value}'})"
 74 |   },
 75 |   "et": {
 76 |     "prefix": "et",
 77 |     "description": "expect to be truthy (coffee)",
 78 |     "body": "expect(${1:target}).toBeTruthy()"
 79 |   },
 80 |   "ef": {
 81 |     "prefix": "ef",
 82 |     "description": "expect to be falsy (coffee)",
 83 |     "body": "expect(${1:target}).toBeFalsy()"
 84 |   },
 85 |   "ed": {
 86 |     "prefix": "ed",
 87 |     "description": "expect to be defined (coffee)",
 88 |     "body": "expect(${1:target}).toBeDefined()"
 89 |   },
 90 |   "en": {
 91 |     "prefix": "en",
 92 |     "description": "expect to be null (coffee)",
 93 |     "body": "expect(${1:target}).toBeNull()"
 94 |   },
 95 |   "ec": {
 96 |     "prefix": "ec",
 97 |     "description": "expect to contain (coffee)",
 98 |     "body": "expect(${1:target}).toContain(${2:value})"
 99 |   },
100 |   "ev": {
101 |     "prefix": "ev",
102 |     "description": "expect to be visible (coffee)",
103 |     "body": "expect(${1:target}).toBeVisible()"
104 |   },
105 |   "eh": {
106 |     "prefix": "eh",
107 |     "description": "expect to be hidden (coffee)",
108 |     "body": "expect(${1:target}).toBeHidden()"
109 |   },
110 |   "notx": {
111 |     "prefix": "notx",
112 |     "description": "expect not (coffee)",
113 |     "body": "expect(${1:target}).not$0"
114 |   },
115 |   "note": {
116 |     "prefix": "note",
117 |     "description": "expect not to equal (coffee)",
118 |     "body": "expect(${1:target}).not.toEqual(${2:value})"
119 |   },
120 |   "notm": {
121 |     "prefix": "notm",
122 |     "description": "expect not to match (coffee)",
123 |     "body": "expect(${1:target}).not.toMatch(${2:pattern})"
124 |   },
125 |   "notha": {
126 |     "prefix": "notha",
127 |     "description": "expect to not have attribute (coffee)",
128 |     "body": "expect(${1:target}).not.toHaveAttr('${2:attr}'${3:, '${4:value}'})"
129 |   },
130 |   "nott": {
131 |     "prefix": "nott",
132 |     "description": "expect not to be truthy (coffee)",
133 |     "body": "expect(${1:target}).not.toBeTruthy()"
134 |   },
135 |   "notf": {
136 |     "prefix": "notf",
137 |     "description": "expect not to be falsy (coffee)",
138 |     "body": "expect(${1:target}).not.toBeFalsy()"
139 |   },
140 |   "notd": {
141 |     "prefix": "notd",
142 |     "description": "expect not to be defined (coffee)",
143 |     "body": "expect(${1:target}).not.toBeDefined()"
144 |   },
145 |   "notn": {
146 |     "prefix": "notn",
147 |     "description": "expect not to be null (coffee)",
148 |     "body": "expect(${1:target}).not.toBeNull()"
149 |   },
150 |   "notc": {
151 |     "prefix": "notc",
152 |     "description": "expect not to contain (coffee)",
153 |     "body": "expect(${1:target}).not.toContain(${2:value})"
154 |   },
155 |   "notv": {
156 |     "prefix": "notv",
157 |     "description": "expect not to be visible (coffee)",
158 |     "body": "expect(${1:target}).not.toBeVisible()"
159 |   },
160 |   "noth": {
161 |     "prefix": "noth",
162 |     "description": "expect not to be hidden (coffee)",
163 |     "body": "expect(${1:target}).not.toBeHidden()"
164 |   },
165 |   "s": {
166 |     "prefix": "s",
167 |     "description": "spy on (coffee)",
168 |     "body": "spyOn(${1:object}, \"${2:method}\")$0"
169 |   },
170 |   "sr": {
171 |     "prefix": "sr",
172 |     "description": "spy on and return (coffee)",
173 |     "body": "spyOn(${1:object}, \"${2:method}\").andReturn(${3:arguments})"
174 |   },
175 |   "st": {
176 |     "prefix": "st",
177 |     "description": "spy on and throw (coffee)",
178 |     "body": "spyOn(${1:object}, \"${2:method}\").andThrow(${3:exception})"
179 |   },
180 |   "sct": {
181 |     "prefix": "sct",
182 |     "description": "spy on and call through (coffee)",
183 |     "body": "spyOn(${1:object}, \"${2:method}\").andCallThrough()"
184 |   },
185 |   "scf": {
186 |     "prefix": "scf",
187 |     "description": "spy on and call fake (coffee)",
188 |     "body": "spyOn(${1:object}, \"${2:method}\").andCallFake(${3:function})"
189 |   },
190 |   "esc": {
191 |     "prefix": "esc",
192 |     "description": "expect was called (coffee)",
193 |     "body": "expect(${1:target}).wasCalled()"
194 |   },
195 |   "escw": {
196 |     "prefix": "escw",
197 |     "description": "expect was called with (coffee)",
198 |     "body": "expect(${1:target}).wasCalledWith(${2:arguments})"
199 |   },
200 |   "notsc": {
201 |     "prefix": "notsc",
202 |     "description": "expect was not called (coffee)",
203 |     "body": "expect(${1:target}).wasNotCalled()"
204 |   },
205 |   "noscw": {
206 |     "prefix": "noscw",
207 |     "description": "expect was not called with (coffee)",
208 |     "body": "expect(${1:target}).wasNotCalledWith(${2:arguments})"
209 |   }
210 | }
211 | 


--------------------------------------------------------------------------------
/cool_snippets/puppet.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "lambda": {
  3 |     "prefix": "lambda",
  4 |     "description": "Lambda function chain-called on a variable",
  5 |     "body": [
  6 |       "\\$${1:varname}.${2:each} |${3:Type} \\$${4:param}| {",
  7 |       "\t$0",
  8 |       "\\}"
  9 |     ]
 10 |   },
 11 |   "cron": {
 12 |     "prefix": "cron",
 13 |     "description": "Cron resource type",
 14 |     "body": [
 15 |       "cron { '${1:name}':",
 16 |       "\tuser    => ${2:user},",
 17 |       "\tcommand => '${3:command}',",
 18 |       "\tminute  => ${3:minute},",
 19 |       "\thour    => ${4:hour},",
 20 |       "\\}"
 21 |     ]
 22 |   },
 23 |   "exec": {
 24 |     "prefix": "exec",
 25 |     "description": "Exec resource type",
 26 |     "body": [
 27 |       "exec { '${1:command}':",
 28 |       "\tcommand => \"${2:$1}\",",
 29 |       "\tuser    => \"${3:root}\",",
 30 |       "\\}"
 31 |     ]
 32 |   },
 33 |   "file": {
 34 |     "prefix": "file",
 35 |     "description": "File resource type",
 36 |     "body": [
 37 |       "file { '${1:name}':",
 38 |       "\tsource => \"puppet://${2:path}\",",
 39 |       "\tmode   => ${3:mode},",
 40 |       "\\}"
 41 |     ]
 42 |   },
 43 |   "File": {
 44 |     "prefix": "File",
 45 |     "description": "Defaults for file",
 46 |     "body": [
 47 |       "File {",
 48 |       "\towner => ${1:username},",
 49 |       "\tgroup => ${2:groupname},",
 50 |       "\\}"
 51 |     ]
 52 |   },
 53 |   "group": {
 54 |     "prefix": "group",
 55 |     "description": "Group resource type",
 56 |     "body": [
 57 |       "group { '${1:groupname}':",
 58 |       "\tensure => ${3:present},",
 59 |       "\tgid    => ${2:gid},",
 60 |       "\\}"
 61 |     ]
 62 |   },
 63 |   "mount": {
 64 |     "prefix": "mount",
 65 |     "description": "Mount resource type",
 66 |     "body": [
 67 |       "mount { '${1:path}':",
 68 |       "\tdevice  => '${2:/dev}',",
 69 |       "\tfstype  => '${3:filesystem}',",
 70 |       "\tensure  => mounted,",
 71 |       "\toptions => 'rw,errors=remount-ro',",
 72 |       "\\}"
 73 |     ]
 74 |   },
 75 |   "package": {
 76 |     "prefix": "package",
 77 |     "description": "Package resource type",
 78 |     "body": [
 79 |       "package { '${1:name}':",
 80 |       "\tensure => ${2:installed},",
 81 |       "\\}"
 82 |     ]
 83 |   },
 84 |   "user": {
 85 |     "prefix": "user",
 86 |     "description": "user resource type",
 87 |     "body": [
 88 |       "user { '${1:username}':",
 89 |       "\tensure     => ${2:present},",
 90 |       "\tuid        => ${3:uid},",
 91 |       "\tgid        => ${4:gid},",
 92 |       "\tcomment    => ${5:gecos},",
 93 |       "\thome       => ${6:homedirectory},",
 94 |       "\tmanagehome => false,",
 95 |       "\trequire    => Group['${7:group'}],",
 96 |       "\\}"
 97 |     ]
 98 |   },
 99 |   "service": {
100 |     "prefix": "service",
101 |     "description": "Service resource type",
102 |     "body": [
103 |       "service { '${1:name}':",
104 |       "\thasstatus => true,",
105 |       "\tenable    => true,",
106 |       "\tensure    => running,",
107 |       "\\}"
108 |     ]
109 |   },
110 |   "alert": {
111 |     "prefix": "alert",
112 |     "description": "Alert Function",
113 |     "body": "alert(\"${1:message}\")$0"
114 |   },
115 |   "crit": {
116 |     "prefix": "crit",
117 |     "description": "Crit Function",
118 |     "body": "crit(\"${1:message}\")$0"
119 |   },
120 |   "debug": {
121 |     "prefix": "debug",
122 |     "description": "Debug Function",
123 |     "body": "debug(\"${1:message}\")$0"
124 |   },
125 |   "defined": {
126 |     "prefix": "defined",
127 |     "description": "Defined Function",
128 |     "body": "defined(${1:Resource}[\"${2:name}\"])$0"
129 |   },
130 |   "emerg": {
131 |     "prefix": "emerg",
132 |     "description": "Emerg Function",
133 |     "body": "emerg(\"${1:message}\")$0"
134 |   },
135 |   "extlookup": {
136 |     "prefix": "extlookup",
137 |     "description": "Extlookup with defaults and custom data file",
138 |     "body": "\\$${1:Variable} = extlookup(\"${2:Lookup}\", ${3:Default}, ${4:Data Source})$0"
139 |   },
140 |   "fail": {
141 |     "prefix": "fail",
142 |     "description": "Fail Function",
143 |     "body": "fail(\"${1:message}\")$0"
144 |   },
145 |   "hiera": {
146 |     "prefix": "hiera",
147 |     "description": "Hiera with defaults and override",
148 |     "body": "\\$${1:Variable} = hiera(\"${2:Lookup}\", ${3:Default}, ${4:Override})$0"
149 |   },
150 |   "hiera_hash": {
151 |     "prefix": "hiera_hash",
152 |     "description": "Hiera Hash with defaults and override",
153 |     "body": "\\$${1:Variable} = hiera_hash(\"${2:Lookup}\", ${3:Default}, ${4:Override})$0"
154 |   },
155 |   "hiera_include": {
156 |     "prefix": "hiera_include",
157 |     "description": "Hiera Include Function",
158 |     "body": "hiera_include(\"${1:Lookup}\")$0"
159 |   },
160 |   "lookup": {
161 |     "prefix": "lookup",
162 |     "description": "Lookup data from hiera",
163 |     "body": "\\$${1:varname} = lookup('${2:hiera::key}')$0"
164 |   },
165 |   "trocla": {
166 |     "prefix": "trocla",
167 |     "description": "Lookup or generate sensitive information",
168 |     "body": "trocla('${1:lookup_key}', '${2:plain}', ${3:'length: 32'})$0"
169 |   },
170 |   "include": {
171 |     "prefix": "include",
172 |     "description": "Include Function",
173 |     "body": "include ${1:classname}$0"
174 |   },
175 |   "info": {
176 |     "prefix": "info",
177 |     "description": "Info Function",
178 |     "body": "info(\"${1:message}\")$0"
179 |   },
180 |   "inline_template": {
181 |     "prefix": "inline_template",
182 |     "description": "Inline Template Function",
183 |     "body": "inline_template(\"<%= ${1:template} %>\")$0"
184 |   },
185 |   "notice": {
186 |     "prefix": "notice",
187 |     "description": "Notice Function",
188 |     "body": "notice(\"${1:message}\")$0"
189 |   },
190 |   "realize": {
191 |     "prefix": "realize",
192 |     "description": "Realize Function",
193 |     "body": "realize(${1:Resource}[\"${2:name}\"])$0"
194 |   },
195 |   "regsubst": {
196 |     "prefix": "regsubst",
197 |     "description": "Regsubst Function",
198 |     "body": "regsubst(\\$${1:Target}, '${2:regexp}', '${3:replacement}')$0"
199 |   },
200 |   "split": {
201 |     "prefix": "split",
202 |     "description": "Split Function",
203 |     "body": "\\$${1:Variable} = split(\\$${1:Target}, '${2:regexp}')$0"
204 |   },
205 |   "versioncmp": {
206 |     "prefix": "versioncmp",
207 |     "description": "Version Compare Function",
208 |     "body": "\\$${1:Variable} = versioncmp('${1:version}', '${2:version}')$0"
209 |   },
210 |   "warning": {
211 |     "prefix": "warning",
212 |     "description": "Warning Function",
213 |     "body": "warning(\"${1:message}\")$0"
214 |   }
215 | }
216 | 


--------------------------------------------------------------------------------
/lua/user/telescope-cfg.lua:
--------------------------------------------------------------------------------
  1 | -- local status_ok, telescope = pcall(require, "telescope")
  2 | -- if not status_ok then
  3 | --   return
  4 | -- end
  5 | --
  6 | -- local actions = require "telescope.actions"
  7 | -- -- telescope.load_extension("media_files")
  8 | --
  9 | -- telescope.setup {
 10 | --   defaults = {
 11 | --
 12 | --     prompt_prefix = " ",
 13 | --     selection_caret = " ",
 14 | --     path_display = { "smart" },
 15 | --     file_ignore_patterns = { ".git/", "node_modules" }, layout_config = {
 16 | --       preview_width = 0.7
 17 | --     },
 18 | --     mappings = {
 19 | --       i = {
 20 | --
 21 | --         ["<C-n>"] = actions.cycle_history_next,
 22 | --         ["<C-p>"] = actions.cycle_history_prev,
 23 | --
 24 | --         ["<C-j>"] = actions.move_selection_next,
 25 | --         ["<C-k>"] = actions.move_selection_previous,
 26 | --
 27 | --         ["<C-c>"] = actions.close,
 28 | --
 29 | --         ["<Down>"] = actions.move_selection_next,
 30 | --         ["<Up>"] = actions.move_selection_previous,
 31 | --
 32 | --         ["<CR>"] = actions.select_default,
 33 | --         ["<C-x>"] = actions.select_horizontal,
 34 | --         ["<C-v>"] = actions.select_vertical,
 35 | --         ["<C-t>"] = actions.select_tab,
 36 | --
 37 | --         ["<C-u>"] = actions.preview_scrolling_up,
 38 | --         ["<C-d>"] = actions.preview_scrolling_down,
 39 | --
 40 | --         ["<PageUp>"] = actions.results_scrolling_up,
 41 | --         ["<PageDown>"] = actions.results_scrolling_down,
 42 | --
 43 | --         ["<Tab>"] = actions.toggle_selection + actions.move_selection_worse,
 44 | --         ["<S-Tab>"] = actions.toggle_selection + actions.move_selection_better,
 45 | --         ["<C-q>"] = actions.send_to_qflist + actions.open_qflist,
 46 | --         ["<M-q>"] = actions.send_selected_to_qflist + actions.open_qflist,
 47 | --         ["<C-l>"] = actions.complete_tag,
 48 | --         ["<C-_>"] = actions.which_key, -- keys from pressing <C-/>
 49 | --       },
 50 | --       n = {
 51 | --         ["<esc>"] = actions.close,
 52 | --         ["<CR>"] = actions.select_default,
 53 | --         ["<C-x>"] = actions.select_horizontal,
 54 | --         ["<C-v>"] = actions.select_vertical,
 55 | --         ["<C-t>"] = actions.select_tab,
 56 | --
 57 | --         ["<Tab>"] = actions.toggle_selection + actions.move_selection_worse,
 58 | --         ["<S-Tab>"] = actions.toggle_selection + actions.move_selection_better,
 59 | --         ["<C-q>"] = actions.send_to_qflist + actions.open_qflist,
 60 | --         ["<M-q>"] = actions.send_selected_to_qflist + actions.open_qflist,
 61 | --
 62 | --         ["j"] = actions.move_selection_next,
 63 | --         ["k"] = actions.move_selection_previous,
 64 | --         ["H"] = actions.move_to_top,
 65 | --         ["M"] = actions.move_to_middle,
 66 | --         ["L"] = actions.move_to_bottom,
 67 | --
 68 | --         ["<Down>"] = actions.move_selection_next,
 69 | --         ["<Up>"] = actions.move_selection_previous,
 70 | --         ["gg"] = actions.move_to_top,
 71 | --         ["G"] = actions.move_to_bottom,
 72 | --
 73 | --         ["<C-u>"] = actions.preview_scrolling_up,
 74 | --         ["<C-d>"] = actions.preview_scrolling_down,
 75 | --
 76 | --         ["<PageUp>"] = actions.results_scrolling_up,
 77 | --         ["<PageDown>"] = actions.results_scrolling_down,
 78 | --
 79 | --         ["?"] = actions.which_key,
 80 | --       },
 81 | --     },
 82 | --   },
 83 | --   pickers = {
 84 | --     -- Default configuration for builtin pickers goes here:
 85 | --     -- picker_name = {
 86 | --     --   picker_config_key = value,
 87 | --     --   ...
 88 | --     -- }
 89 | --     -- Now the picker_config_key will be applied every time you call this
 90 | --     -- builtin picker
 91 | --   },
 92 | --   extensions = {
 93 | --     -- media_files = {
 94 | --       -- filetypes whitelist
 95 | --       -- defaults to {"png", "jpg", "mp4", "webm", "pdf"}
 96 | --     --  filetypes = { "png", "webp", "jpg", "jpeg" },
 97 | --     --  find_cmd = "rg" -- find command (defaults to `fd`)
 98 | --  --   }
 99 | --     -- Your extension configuration goes here:
100 | --     -- extension_name = {
101 | --     --   extension_config_key = value,
102 | --     -- }
103 | --     -- please take a look at the readme of the extension you want to configure
104 | --   },
105 | -- }
106 | --
107 | 
108 | local present, telescope = pcall(require, "telescope")
109 | 
110 | if not present then
111 |   return
112 | end
113 | 
114 | local icons = require("user.icons")
115 | 
116 | vim.g.theme_switcher_loaded = true
117 | 
118 | local options = {
119 |   defaults = {
120 |     vimgrep_arguments = {
121 |       "rg",
122 |       "--color=never",
123 |       "--no-heading",
124 |       "--with-filename",
125 |       "--line-number",
126 |       "--column",
127 |       "--smart-case",
128 |     },
129 |     -- prompt_prefix = "   ",
130 |     -- selection_caret = "  ",
131 |     prompt_prefix = icons.ui.Search .. " ",
132 |     selection_caret = icons.ui.ArrowRight .. " ",
133 |     entry_prefix = "  ",
134 |     initial_mode = "insert",
135 |     selection_strategy = "reset",
136 |     sorting_strategy = "ascending",
137 |     layout_strategy = "horizontal",
138 |     layout_config = {
139 |       horizontal = {
140 |         prompt_position = "top",
141 |         preview_width = 0.55,
142 |         results_width = 0.8,
143 |       },
144 |       vertical = {
145 |         mirror = false,
146 |       },
147 |       width = 0.80,
148 |       height = 0.80,
149 |       preview_cutoff = 120,
150 |     },
151 |     file_sorter = require("telescope.sorters").get_fuzzy_file,
152 |     file_ignore_patterns = { "node_modules" },
153 |     generic_sorter = require("telescope.sorters").get_generic_fuzzy_sorter,
154 |     path_display = { "truncate" },
155 |     winblend = 0,
156 |     border = {},
157 |     borderchars = { "─", "│", "─", "│", "╭", "╮", "╯", "╰" },
158 |     color_devicons = true,
159 |     set_env = { ["COLORTERM"] = "truecolor" }, -- default = nil,
160 |     file_previewer = require("telescope.previewers").vim_buffer_cat.new,
161 |     grep_previewer = require("telescope.previewers").vim_buffer_vimgrep.new,
162 |     qflist_previewer = require("telescope.previewers").vim_buffer_qflist.new,
163 |     -- Developer configurations: Not meant for general override
164 |     buffer_previewer_maker = require("telescope.previewers").buffer_previewer_maker,
165 |     mappings = {
166 |       n = { ["q"] = require("telescope.actions").close },
167 |     },
168 |   },
169 | 
170 |   extensions_list = {
171 |     "themes",
172 |     "terms",
173 |     fzf = {
174 |       fuzzy = true,                     -- false will only do exact matching
175 |       override_generic_sorter = true,   -- override the generic sorter
176 |       override_file_sorter = true,      -- override the file sorter
177 |       case_mode = "smart_case",         -- or "ignore_case" or "respect_case"
178 |     },
179 |   },
180 | 
181 | }
182 | 
183 | -- check for any override
184 | -- options = require("core.utils").load_override(options, "nvim-telescope/telescope.nvim")
185 | telescope.setup(options)
186 | 
187 | -- load extensions
188 | -- pcall(function()
189 | -- for _, ext in ipairs(options.extensions_list) do
190 | -- 	telescope.load_extension(ext)
191 | -- end
192 | -- end)
193 | 


--------------------------------------------------------------------------------