path: root/config/nvim-archive/external_settings/plugins.vim

" https://github.com/junegunn/vim-plug
call plug#begin(system('echo -n "${XDG_CONFIG_HOME:-$HOME/.config}/nvim/plugged"'))


" <-- Syntax Highlighting-->
	Plug 'ap/vim-css-color'														  " Enable CSS syntax
	Plug 'roobert/tailwindcss-colorizer-cmp.nvim'								  " CSS Colorizer
	Plug 'bfrg/vim-cpp-modern'													  " C/C++ Syntax Highlighting
	Plug 'kien/rainbow_parentheses.vim'
	Plug 'uiiaoo/java-syntax.vim'												  " Syntax Highlighting for Java
	"Plug 'lukas-reineke/indent-blankline.nvim'
	Plug 'nvim-treesitter/nvim-treesitter', {'do': ':TSUpdate'}
	Plug 'folke/todo-comments.nvim'
	" <-- END Syntax High lighting-->

	" <-- Colour Schemes -->
	Plug 'NLKNguyen/papercolor-theme'
	Plug 'sts10/vim-pink-moon'
	Plug 'rafi/awesome-vim-colorschemes'
	Plug 'catppuccin/nvim', { 'as': 'catppuccin' }
	Plug 'chriskempson/base16-vim'
	Plug 'justinmk/vim-syntax-extra'
	" <-- END Colour Schemes -->

	" <-- Completion and linting -->
	Plug 'neoclide/coc.nvim', {'branch': 'release'}								  " Auto Completion
	Plug 'dense-analysis/ale'													  " Real time Linting
	" Plug 'tpope/vim-surround'													  " Change what something is surrounded by
	Plug 'kylechui/nvim-surround'
	Plug 'alvan/vim-closetag'													  " Close HTML tags
	Plug 'gennaro-tedesco/nvim-commaround'										  " Toggle Comments in visual block
	Plug 'roobert/search-replace.nvim'											  " Replace searched for text
	" <-- END Completion and linting -->

	" <-- Navigation -->
	"Plug 'ms-jpq/chadtree', {'branch': 'chad', 'do': 'python3 -m chadtree deps'}  " File Manager
	"Plug 'preservim/nerdtree'                                                     " File Manager
	""Plug 'tiagofumo/vim-nerdtree-syntax-highlight'                                " NERDTree Syntax Addon
	Plug 'TheBlob42/drex.nvim'													  " Directory Explorer
	Plug 'elihunter173/dirbuf.nvim'												  " Directory Buffer
	Plug 'mg979/vim-visual-multi', {'branch': 'master'}							  " More cursers in visual mode
	Plug 'junegunn/fzf.vim'
	Plug 'nvim-lua/plenary.nvim'
	Plug 'nvim-telescope/telescope.nvim' ", { 'tag': '0.1.8' }
	Plug 'nvim-tree/nvim-tree.lua'
	Plug 's1n7ax/nvim-terminal'
	" <-- END Navigation -->

	" <-- MISC -->
	" https://github.com/ThePrimeagen/git-worktree.nvim
	Plug 'ThePrimeagen/vim-be-good'
	" Plug 'ryanoasis/vim-devicons'
	Plug 'voldikss/vim-floaterm'                                                  " Terminal
	Plug 'iamcco/markdown-preview.nvim', { 'do': 'cd app && yarn install' }       " Live markdown preview in browser
	Plug 'strboul/urlview.vim'													  " Open URLS
	Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
	" Plug 'ibhagwan/fzf-lua'
	Plug 'vimwiki/vimwiki'														  " Note taking in vim
	Plug 'mbbill/undotree'                                                        " Undo history tree
	"Plug 'epwalsh/obsidian.nvim'
	" <-- END MISC -->

	" <-- Plugin Dependencies -->
	Plug 'nvim-lua/plenary.nvim'
	" <-- END Plugin Dependencies -->

	" <-- Git Integration -->
	Plug 'sindrets/diffview.nvim'
	Plug 'lewis6991/gitsigns.nvim'
	Plug 'tpope/vim-fugitive'
	" <-- END Git Integration -->


	" <-- Dependencies -->
	Plug 'nvim-lua/plenary.nvim'
	" <-- END Dependencies -->


	"https://github.com/Zeioth/compiler.nvim
	"https://github.com/rmagatti/goto-preview
	"https://github.com/SmiteshP/nvim-navbuddy


	"
	"
	"
	"

	call plug#end()


" <----- Plugin Configs -----> "






" <----- nvim-terminal -----> "
" :lua require('nvim-terminal').setup()

lua << EOF


vim.o.hidden = false
require('nvim-terminal').setup({
    window = {
        -- Do `:h :botright` for more information
        -- NOTE: width or height may not be applied in some "pos"
        position = 'botright',

        -- Do `:h split` for more information
        split = 'sp',

        -- Width of the terminal
        width = 50,

        -- Height of the terminal
        height = 15,
    },

    -- keymap to disable all the default keymaps
    disable_default_keymaps = false,

    -- keymap to toggle open and close terminal window
    toggle_keymap = '<leader>;',

    -- increase the window height by when you hit the keymap
    window_height_change_amount = 2,

    -- increase the window width by when you hit the keymap
    window_width_change_amount = 2,

    -- keymap to increase the window width
    increase_width_keymap = '<leader><leader>+',

    -- keymap to decrease the window width
    decrease_width_keymap = '<leader><leader>-',

    -- keymap to increase the window height
    increase_height_keymap = '<leader>+',

    -- keymap to decrease the window height
    decrease_height_keymap = '<leader>-',

    terminals = {
        -- keymaps to open nth terminal
        {keymap = '<leader>1'},
        {keymap = '<leader>2'},
        {keymap = '<leader>3'},
        {keymap = '<leader>4'},
        {keymap = '<leader>5'},
    },

})
EOF

tnoremap <Esc> <C-\><C-n>
" <----- END nvim-terminal -----> "



lua << EOF
require('gitsigns').setup {
  signs = {
    add          = { text = '┃' },
    change       = { text = '┃' },
    delete       = { text = '_' },
    topdelete    = { text = '‾' },
    changedelete = { text = '~' },
    untracked    = { text = '┆' },
  },
  -- ... include other configurations as needed
}
EOF


"<----- indent-blankline -----> "
"lua << EOF
"require("ibl").setup()
"EOF

" au BufEnter *.* :IBLToggleScope
" <----- END indent-blankline -----> "


"<----- vim-surround -----> "
lua << EOF
require("nvim-surround").setup()
EOF
"<----- END vim-surround -----> "


" <----- todo-comments -----> "
lua << EOF
require('todo-comments').setup {
	 signs = true, -- show icons in the signs column
  sign_priority = 8, -- sign priority
  -- keywords recognized as todo comments
  keywords = {
    FIX = {
      icon = " ", -- icon used for the sign, and in search results
      color = "error", -- can be a hex color, or a named color (see below)
      alt = { "FIXME", "BUG", "FIXIT", "ISSUE"}, -- a set of other keywords that all map to this FIX keywords
      -- signs = false, -- configure signs for some keywords individually
    },
    TODO = { icon = " ", color = "info" },
    HACK = { icon = " ", color = "warning" },
    WARN = { icon = " ", color = "warning", alt = { "WARNING", "XXX" } },
    PERF = { icon = " ", alt = { "OPTIM", "PERFORMANCE", "OPTIMIZE" } },
    NOTE = { icon = " ", color = "hint", alt = { "INFO" } },
    TEST = { icon = "⏲ ", color = "test", alt = { "TESTING", "PASSED", "FAILED" } },
    DEBUG = { icon = "🐛", color = "info"},
    FIX = { icon = "🔧", color = "#FF00FF"},
  },
  gui_style = {
    fg = "NONE", -- The gui style to use for the fg highlight group.
    bg = "BOLD", -- The gui style to use for the bg highlight group.
  },
  merge_keywords = true, -- when true, custom keywords will be merged with the defaults
  -- highlighting of the line containing the todo comment
  -- * before: highlights before the keyword (typically comment characters)
  -- * keyword: highlights of the keyword
  -- * after: highlights after the keyword (todo text)
  highlight = {
    multiline = true, -- enable multine todo comments
    multiline_pattern = "^.", -- lua pattern to match the next multiline from the start of the matched keyword
    multiline_context = 10, -- extra lines that will be re-evaluated when changing a line
    before = "", -- "fg" or "bg" or empty
    keyword = "wide", -- "fg", "bg", "wide", "wide_bg", "wide_fg" or empty. (wide and wide_bg is the same as bg, but will also highlight surrounding characters, wide_fg acts accordingly but with fg)
    after = "fg", -- "fg" or "bg" or empty
    pattern = [[.*<(KEYWORDS)\s*:]], -- pattern or table of patterns, used for highlighting (vim regex)
    comments_only = true, -- uses treesitter to match keywords in comments only
    max_line_len = 400, -- ignore lines longer than this
    exclude = {}, -- list of file types to exclude highlighting
  },
  -- list of named colors where we try to extract the guifg from the
  -- list of highlight groups or use the hex color if hl not found as a fallback
  colors = {
    error = { "DiagnosticError", "ErrorMsg", "#DC2626" },
    warning = { "DiagnosticWarn", "WarningMsg", "#FBBF24" },
    info = { "DiagnosticInfo", "#2563EB" },
    hint = { "DiagnosticHint", "#10B981" },
    default = { "Identifier", "#7C3AED" },
    test = { "Identifier", "#FF00FF" }
  },
  search = {
    command = "rg",
    args = {
      "--color=never",
      "--no-heading",
      "--with-filename",
      "--line-number",
      "--column",
    },
    -- regex that will be used to match keywords.
    -- don't replace the (KEYWORDS) placeholder
    pattern = [[\b(KEYWORDS):]], -- ripgrep regex
    -- pattern = [[\b(KEYWORDS)\b]], -- match without the extra colon. You'll likely get false positives
  },
}

vim.keymap.set("n", "]t", function()
  require("todo-comments").jump_next()
end, { desc = "Next todo comment" })

vim.keymap.set("n", "[t", function()
  require("todo-comments").jump_prev()
end, { desc = "Previous todo comment" })

-- You can also specify a list of valid jump keywords

vim.keymap.set("n", "]t", function()
  require("todo-comments").jump_next({keywords = { "ERROR", "WARNING" }})
end, { desc = "Next error/warning todo comment" })
EOF
" <----- END todo-comments -----> "


" <----- Telescope -----> "
" <----- END Telescope -----> "


" <----- Nvim Tree -----> "
lua << EOF
-- disable netrw at the very start of your init.lua
vim.g.loaded_netrw = 1
vim.g.loaded_netrwPlugin = 1

-- optionally enable 24-bit colour
vim.opt.termguicolors = true

-- empty setup using defaults
require("nvim-tree").setup()

-- OR setup with some options
require("nvim-tree").setup({
  sort = {
    sorter = "case_sensitive",
  },
  view = {
    width = 30,
  },
  renderer = {
    group_empty = true,
  },
  filters = {
    dotfiles = true,
  },
})
EOF

" <----- END Nvim Tree -----> "



" --- Float Term --- "
nmap <leader>t  :FloatermNew<enter>
nmap <leader>Tr :FloatermNew --autoclose=0 gcc % -o %< && ./%<
"FloatermNew --height=0.6 --width=0.4 --wintype=float --name=floaterm1 --position=topleft --autoclose=2 ranger --cmd="cd ~"
" - END Float Term - "




" --- quick scope --- "
let g:qs_highlight_on_keys = ['f', 'F']
" - END scope - "


" --- Chad Tree --- "
nnoremap <leader>v <cmd>CHADopen<cr>
" --- END Chad Tree--- "

" --- NERD Tree --- "
nnoremap <leader>n :NERDTreeFocus<CR>
nnoremap <C-n> :NERDTree<CR>
nnoremap <C-t> :NERDTreeToggle<CR>
nnoremap <C-f> :NERDTreeFind<CR>

" autocmd VimEnter * NERDTree | wincmd p
" --- END NERD Tree --- "

" --- nvim-cursorword --- "
"hi default CursorWord cterm=underline gui=underline
" --- END nvim-cursorword --- "




" --- Linting --- "
let g:ale_linters = {
    \ 'python': ['pylint'],
    \ 'cpp': ['clang'],
    \ 'c': ['clang']
\}
" --- END Linting ---- "





" --- Coc --- "

" Coc Extensions
let g:coc_global_extensions = [
  \ 'coc-css',
  \ 'coc-html',
  \ 'coc-clangd',
  "\ 'coc-java',
  \ 'coc-pairs',
   \ 'coc-vimtex',
  \ 'coc-snippets',
  \ 'coc-highlight'
\ ]

let g:coc_enable_diagnostic_sign = 1



" Always show the signcolumn, otherwise it would shift the text each time
" diagnostics appear/become resolved
set signcolumn=yes

" Use tab for trigger completion with characters ahead and navigate
" NOTE: There's always complete item selected by default, you may want to enable
" no select by `"suggest.noselect": true` in your configuration file
" NOTE: Use command ':verbose imap <tab>' to make sure tab is not mapped by
" other plugin before putting this into your config
inoremap <silent><expr> <TAB>
      \ coc#pum#visible() ? coc#pum#next(1) :
      \ CheckBackspace() ? "\<Tab>" :
      \ coc#refresh()
inoremap <expr><S-TAB> coc#pum#visible() ? coc#pum#prev(1) : "\<C-h>"

" Make <CR> to accept selected completion item or notify coc.nvim to format
" <C-g>u breaks current undo, please make your own choice
inoremap <silent><expr> <CR> coc#pum#visible() ? coc#pum#confirm()
                              \: "\<C-g>u\<CR>\<c-r>=coc#on_enter()\<CR>"

function! CheckBackspace() abort
  let col = col('.') - 1
  return !col || getline('.')[col - 1]  =~# '\s'
endfunction

" Use <c-space> to trigger completion
if has('nvim')
  inoremap <silent><expr> <c-space> coc#refresh()
else
  inoremap <silent><expr> <c-@> coc#refresh()
endif

" Use `[g` and `]g` to navigate diagnostics
" Use `:CocDiagnostics` to get all diagnostics of current buffer in location list
nmap <silent> [g <Plug>(coc-diagnostic-prev)
nmap <silent> ]g <Plug>(coc-diagnostic-next)

" GoTo code navigation
nmap <silent> gd <Plug>(coc-definition)
nmap <silent> gy <Plug>(coc-type-definition)
nmap <silent> gi <Plug>(coc-implementation)
nmap <silent> gr <Plug>(coc-references)

" Use K to show documentation in preview window
nnoremap <silent> K :call ShowDocumentation()<CR>

function! ShowDocumentation()
  if CocAction('hasProvider', 'hover')
    call CocActionAsync('doHover')
  else
    call feedkeys('K', 'in')
  endif
endfunction

" Highlight the symbol and its references when holding the cursor
autocmd CursorHold * silent call CocActionAsync('highlight')

" Symbol renaming
nmap <leader>rn <Plug>(coc-rename)

" Formatting selected code
xmap <leader>f  <Plug>(coc-format-selected)
nmap <leader>f  <Plug>(coc-format-selected)

augroup mygroup
  autocmd!
  " Setup formatexpr specified filetype(s)
  autocmd FileType typescript,json setl formatexpr=CocAction('formatSelected')
  " Update signature help on jump placeholder
  autocmd User CocJumpPlaceholder call CocActionAsync('showSignatureHelp')
augroup end

" Applying code actions to the selected code block
" Example: `<leader>aap` for current paragraph
xmap <leader>a  <Plug>(coc-codeaction-selected)
nmap <leader>a  <Plug>(coc-codeaction-selected)

" Remap keys for applying code actions at the cursor position
nmap <leader>ac  <Plug>(coc-codeaction-cursor)
" Remap keys for apply code actions affect whole buffer
nmap <leader>as  <Plug>(coc-codeaction-source)
" Apply the most preferred quickfix action to fix diagnostic on the current line
nmap <leader>qf  <Plug>(coc-fix-current)

" Remap keys for applying refactor code actions
nmap <silent> <leader>re <Plug>(coc-codeaction-refactor)
xmap <silent> <leader>r  <Plug>(coc-codeaction-refactor-selected)
nmap <silent> <leader>r  <Plug>(coc-codeaction-refactor-selected)

" Run the Code Lens action on the current line
nmap <leader>cl  <Plug>(coc-codelens-action)

" Map function and class text objects
" NOTE: Requires 'textDocument.documentSymbol' support from the language server
xmap if <Plug>(coc-funcobj-i)
omap if <Plug>(coc-funcobj-i)
xmap af <Plug>(coc-funcobj-a)
omap af <Plug>(coc-funcobj-a)
xmap ic <Plug>(coc-classobj-i)
omap ic <Plug>(coc-classobj-i)
xmap ac <Plug>(coc-classobj-a)
omap ac <Plug>(coc-classobj-a)

" Remap <C-f> and <C-b> to scroll float windows/popups
if has('nvim-0.4.0') || has('patch-8.2.0750')
  nnoremap <silent><nowait><expr> <C-f> coc#float#has_scroll() ? coc#float#scroll(1) : "\<C-f>"
  nnoremap <silent><nowait><expr> <C-b> coc#float#has_scroll() ? coc#float#scroll(0) : "\<C-b>"
  inoremap <silent><nowait><expr> <C-f> coc#float#has_scroll() ? "\<c-r>=coc#float#scroll(1)\<cr>" : "\<Right>"
  inoremap <silent><nowait><expr> <C-b> coc#float#has_scroll() ? "\<c-r>=coc#float#scroll(0)\<cr>" : "\<Left>"
  vnoremap <silent><nowait><expr> <C-f> coc#float#has_scroll() ? coc#float#scroll(1) : "\<C-f>"
  vnoremap <silent><nowait><expr> <C-b> coc#float#has_scroll() ? coc#float#scroll(0) : "\<C-b>"
endif

" Use CTRL-S for selections ranges
" Requires 'textDocument/selectionRange' support of language server
nmap <silent> <C-s> <Plug>(coc-range-select)
xmap <silent> <C-s> <Plug>(coc-range-select)

" Add `:Format` command to format current buffer
command! -nargs=0 Format :call CocActionAsync('format')

" Add `:Fold` command to fold current buffer
command! -nargs=? Fold :call     CocAction('fold', <f-args>)

" Add `:OR` command for organize imports of the current buffer
command! -nargs=0 OR   :call     CocActionAsync('runCommand', 'editor.action.organizeImport')

" Add (Neo)Vim's native statusline support
" NOTE: Please see `:h coc-status` for integrations with external plugins that
" provide custom statusline: lightline.vim, vim-airline
set statusline^=%{coc#status()}%{get(b:,'coc_current_function','')}

" Mappings for CoCList
" Show all diagnostics
nnoremap <silent><nowait> <space>a  :<C-u>CocList diagnostics<cr>
" Manage extensions
nnoremap <silent><nowait> <space>e  :<C-u>CocList extensions<cr>
" Show commands
nnoremap <silent><nowait> <space>c  :<C-u>CocList commands<cr>
" Find symbol of current document
nnoremap <silent><nowait> <space>o  :<C-u>CocList outline<cr>
" Search workspace symbols
nnoremap <silent><nowait> <space>s  :<C-u>CocList -I symbols<cr>
" Do default action for next item
nnoremap <silent><nowait> <space>j  :<C-u>CocNext<CR>
" Do default action for previous item
nnoremap <silent><nowait> <space>k  :<C-u>CocPrev<CR>
" Resume latest coc list
nnoremap <silent><nowait> <space>p  :<C-u>CocListResume<CR>



" - END Coc - "


" <----- END Plugin Configs -----> "