diff --git a/.eslintrc.json b/.eslintrc.json index 36f8935..ae6de37 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -1,19 +1,22 @@ { - "env": { - "browser": true, - "es2021": true, - "node": true - }, "extends": "standard-with-typescript", - "parserOptions": { - "ecmaVersion": "latest", - "sourceType": "module" - }, - "rules": { - "indent": ["error", 4], - "semi": ["error", "always"], - "quotes": ["error", "double"], - "comma-dangle": ["error", "only-multiline"], - "space-before-function-paren": ["error", "never"] + "overrideConfig": { + "env": { + "browser": true, + "es2021": true, + "node": true + }, + "rules": { + "indent": ["error", 4], + "semi": ["error", "always"], + "quotes": ["error", "double"], + "comma-dangle": ["error", "only-multiline"], + "space-before-function-paren": ["error", "never"], + "newline-per-chained-call": ["error", { "ignoreChainWithDepth": 2 }] + }, + "parserOptions": { + "ecmaVersion": "latest", + "sourceType": "module" + } } } diff --git a/.prettierrc.json b/.prettierrc.json index 97cf44a..2453969 100644 --- a/.prettierrc.json +++ b/.prettierrc.json @@ -3,5 +3,6 @@ "tabWidth": 4, "semi": true, "singleQuote": false, - "spaceBeforeFunctionParen": false + "spaceBeforeFunctionParen": false, + "printWidth": 120 } diff --git a/README.md b/README.md deleted file mode 100644 index 453653d..0000000 --- a/README.md +++ /dev/null @@ -1,26 +0,0 @@ -# Purpose - -Get up and going in Linux with some nice bash aliases, neovim configuration + plugins, and tmux. - -# Prerequisites - - - tmux - - npm or nvm - - neovim 0.8+ - -# Installation - -Symlink the config files to `~/.config/nvim` and `~`, respectively, OR just run `./install.sh` which will do that for you. - - > ln -s $HOME/repos/dotfiles/init.lua $HOME/.config/nvim/init.lua - > ln -s $HOME/repos/dotfiles/vimrc.vim $HOME/.config/nvim/vimrc.vim - > ln -s $HOME/repos/dotfiles/bash_aliases $HOME/.bash_aliases - > ln -s $HOME/repos/dotfiles/tmux.conf $HOME/.tmux.conf - -After Coc is installed, install coc-pyright and pyright: - - # terminal: - > npm install -g pyright - > sudo apt install ripgrep # or brew install - # inside nvim: - :CocInstall coc-pyright diff --git a/bash_aliases b/bash_aliases index 15788a7..3146293 100644 --- a/bash_aliases +++ b/bash_aliases @@ -4,19 +4,144 @@ alias bb='vi ~/.bashrc' alias ba='vi ~/.bash_aliases' alias bs='vi ~/.git_secret' alias r='cd ~/repos && pwd' -alias vl='vi ~/.config/nvim/init.lua' -alias vv='vi ~/.config/nvim/vimrc.vim' +alias vv='vi ~/.config/nvim/init.lua' +alias dx='deactivate' +alias ph='poetry shell' +alias ta='tmux a' alias gb='git branch' alias gl='git log' +alias pp='vi ~/.profile' alias pg='git pull origin $(git branch --show-current)' alias gp='git push origin $(git branch --show-current)' alias gs='git status' -alias gd='git diff' -alias ga='git add --all' -alias i='ipython' -alias python=python3 -alias v="vagrant ssh" +alias gt='git stash' alias tt='vi ~/.tmux.conf' -alias t='tree -a -I "*.pyc|*__pycache__|.git|.data|.pytest_cache|.ruff_cache"' -alias p3=python3 +alias gd='git diff --diff-filter=ACMRTUXB' +alias gha='git rev-parse --short HEAD' +alias gf='git fetch' +alias ga='git add --all' alias l='ls -lrta' +alias i='ipython' +alias python3=/usr/local/vitol/pyenv/versions/3.11.4/bin/python +alias p3=python3 +alias t='tree -a -I "*.pyc|*__pycache__|.git|.data|.pytest_cache|.ruff_cache|.mypy_cache|node_modules|env"' +alias pl='poetry shell' +alias act='source env/bin/activate' +alias lsd='ls -d */' +alias tm='tmux' +alias c='cal --three' + +n() { + local latest_file + latest_file=$(find . -type f \ + -not -path '*/\.*' \ + -not -path '*_cache/*' \ + -not -path '*/__pycache__/*' \ + -not -name '*.pyc' \ + -not -name 'pyproject.toml' \ + -not -name 'poetry.lock' \ + -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" ") + + if [ -n "$latest_file" ]; then + nvim "$latest_file" + else + echo "No files found." + fi +} +function gc() { + git commit -m "$1" +} + +v() { + local file + file=$(find . -type f \ + -not -path "*/node_modules/*" \ + -not -path "*/__pycache__/*" \ + -not -path "*/venv/*" \ + -not -path "*/.venv/*" \ + -not -path "*/*cache/*" \ + -not -path "*/.git/*" \ + -not -path "*/.reports/*" \ + | fzf) + if [[ -n $file ]]; then + vi "$file" + fi +} + +function gh() { + git checkout -b $1 +} + +vm() { + # open the most recently modified file in the current directory + + local substring="$1" + local modified_files + local selected_files + + modified_files=$(git status --porcelain | grep '^.M' | awk '{print $2}') + + if [ -z "$substring" ]; then + selected_files=$(echo "$modified_files" | fzf --multi --preview 'git diff --color=always {} | head -500') + else + matching_files=$(echo "$modified_files" | grep "$substring") + count=$(echo "$matching_files" | wc -l) + + if [ "$count" -eq 1 ]; then + selected_files="$matching_files" + elif [ "$count" -gt 1 ]; then + selected_files=$(echo "$matching_files" | fzf --multi --preview 'git diff --color=always {} | head -500') + fi + fi + + if [ -n "$selected_files" ]; then + echo "$selected_files" | while read -r file; do + diff_output=$(git diff -U0 "$file") + first_change=$(echo "$diff_output" | grep -m1 '^@@') + if [ -n "$first_change" ]; then + line_info=$(echo "$first_change" | awk '{print $3}' | tr -d '+') + line_number=$(echo "$line_info" | cut -d, -f1) + change_type=$(echo "$diff_output" | grep -A1 "$first_change" | tail -n1 | cut -c1) + if [ "$change_type" = "-" ]; then + line_number=$((line_number + 1)) + fi + $EDITOR "+$line_number" "$file" + else + $EDITOR "$file" + fi + done + else + echo "No files selected." + fi +} + +delete_branches_except() { + if [[ "$#" -eq 0 || "$1" != "--except" ]]; then + echo "Error: You must supply at least one '--except' argument." + return 1 + fi + + shift # Remove the '--except' argument + + if [[ "$#" -eq 0 ]]; then + echo "Error: You must specify at least one branch to keep." + return 1 + fi + + # Store branches to keep in an array + local branches_to_keep=("$@") + + # Get all local branches + local all_branches + all_branches=$(git branch --format='%(refname:short)') + + # Loop through all branches and delete those not in the branches_to_keep array + for branch in $all_branches; do + if [[ ! " ${branches_to_keep[*]} " =~ " ${branch} " ]]; then + echo "Deleting branch: $branch" + git branch -D "$branch" + else + echo "Keeping branch: $branch" + fi + done +} diff --git a/init.lua b/init.lua index 98d2b3c..10452ff 100644 --- a/init.lua +++ b/init.lua @@ -1,215 +1,881 @@ -local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" +-- Set as the leader key +-- See `:help mapleader` +-- NOTE: Must happen before plugins are loaded (otherwise wrong leader will be used) +vim.g.mapleader = " " +vim.g.maplocalleader = " " +vim.opt.cmdheight = 0 -if not vim.loop.fs_stat(lazypath) then - vim.fn.system({ - "git", - "clone", - "--filter=blob:none", - "https://github.com/folke/lazy.nvim.git", - "--branch=stable", -- latest stable release - lazypath, - }) -end +-- Set to true if you have a Nerd Font installed and selected in the terminal +vim.g.have_nerd_font = true -vim.opt.rtp:prepend(lazypath) -vim.opt.colorcolumn = "120" -vim.opt.updatetime = 50 -- improve perf, less frequent swp writes -vim.opt.termguicolors = true -vim.opt.hlsearch = false -vim.opt.incsearch = true -vim.opt.smartindent = true -vim.opt.scrolloff = 8 +-- [[ Setting options ]] +-- See `:help vim.opt` +-- NOTE: You can change these options as you wish! +-- For more options, you can see `:help option-list` + +-- Make line numbers default +vim.opt.number = true +vim.opt.relativenumber = true + +-- Enable mouse mode, can be useful for resizing splits for example! +vim.opt.mouse = "a" + +-- Don't show the mode, since it's already in the status line +vim.opt.showmode = false + +-- Enable break indent +vim.opt.breakindent = true + +-- Save undo history +vim.opt.undofile = true + +-- Case-insensitive searching UNLESS \C or one or more capital letters in the search term +vim.opt.ignorecase = true +vim.opt.smartcase = true + +-- Keep signcolumn on by default vim.opt.signcolumn = "yes" -vim.opt.isfname:append("@-@") -require("lazy").setup({ - "folke/tokyonight.nvim", - "tpope/vim-commentary", - { - "folke/trouble.nvim", - dependencies = { "nvim-tree/nvim-web-devicons" }, - opts = {}, - }, - { - "nvim-telescope/telescope.nvim", - tag = "0.1.5", - dependencies = { "nvim-lua/plenary.nvim", "BurntSushi/ripgrep" }, - }, - { - "nvim-telescope/telescope-fzf-native.nvim", - build = "cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release && cmake --build build --config Release && cmake --install build --prefix build", - }, - { "VonHeikemen/lsp-zero.nvim", branch = "v3.x" }, - { "neovim/nvim-lspconfig" }, - { "nvim-treesitter/nvim-treesitter" }, - { - "stevearc/conform.nvim", - event = { "BufReadPre", "BufNewFile" }, - config = function() - require("conform").setup({ - formatters_by_ft = { - lua = { "stylua" }, - svelte = { { "prettierd", "prettier" } }, - javascript = { { "prettierd", "prettier" } }, - typescript = { { "prettierd", "prettier" } }, - javascriptreact = { { "prettierd", "prettier" } }, - typescriptreact = { { "prettierd", "prettier" } }, - json = { { "prettierd", "prettier" } }, - graphql = { { "prettierd", "prettier" } }, - java = { "google-java-format" }, - kotlin = { "ktlint" }, - ruby = { "standardrb" }, - markdown = { { "prettierd", "prettier" } }, - erb = { "htmlbeautifier" }, - html = { "htmlbeautifier" }, - bash = { "beautysh" }, - proto = { "buf" }, - rust = { "rustfmt" }, - yaml = { "yamlfix" }, - toml = { "taplo" }, - css = { { "prettierd", "prettier" } }, - scss = { { "prettierd", "prettier" } }, - }, - format_on_save = { - -- These options will be passed to conform.format() - timeout_ms = 500, - lsp_fallback = true, - }, - }) - end, - }, - { - "mfussenegger/nvim-lint", - event = { - "BufReadPre", - "BufNewFile", - }, - config = function() - local lint = require("lint") - lint.linters_by_ft = { - javascript = { "eslint_d" }, - typescript = { "eslint_d" }, - javascriptreact = { "eslint_d" }, - typescriptreact = { "eslint_d" }, - svelte = { "eslint_d" }, - kotlin = { "ktlint" }, - terraform = { "tflint" }, - ruby = { "standardrb" }, - } - local lint_augroup = vim.api.nvim_create_augroup("lint", { clear = true }) - vim.api.nvim_create_autocmd({ "BufEnter", "BufWritePost", "InsertLeave" }, { - group = lint_augroup, - callback = function() - lint.try_lint() - end, - }) - end, - }, - { "hrsh7th/nvim-cmp" }, - { "hrsh7th/cmp-nvim-lsp" }, - { "hrsh7th/cmp-buffer" }, - { "hrsh7th/vim-vsnip" }, - { "L3MON4D3/LuaSnip" }, - { "czheo/mojo.vim" }, - { "neoclide/coc.nvim", branch = "release" }, - { - "kylechui/nvim-surround", - version = "*", - event = "VeryLazy", - config = function() - require("nvim-surround").setup({}) - end, - }, -}) -require("telescope").setup({ - extensions = { - fzf = { - fuzzy = true, -- false will only do exact matching - override_generic_sorter = true, -- override the generic sorter - override_file_sorter = true, -- override the file sorter - case_mode = "smart_case", -- or "ignore_case" or "respect_case" - -- the default case_mode is "smart_case" - }, - }, -}) -local vimrc = vim.fn.stdpath("config") .. "/vimrc.vim" -vim.cmd.source(vimrc) +-- Decrease update time +vim.opt.updatetime = 250 -local cmp = require("cmp") -cmp.setup({ - snippet = { - expand = function(args) - vim.fn["vsnip#anonymous"](args.body) - end, - }, +-- Configure how new splits should be opened +vim.opt.splitright = true +vim.opt.splitbelow = true - mapping = { - ["C-y"] = cmp.mapping.confirm({ select = true }), - }, +-- Sets how neovim will display certain whitespace characters in the editor. +-- See `:help 'list'` +-- and `:help 'listchars'` +vim.opt.list = true +vim.opt.listchars = { tab = "» ", trail = "·", nbsp = "␣" } - sources = { - { name = "nvim_lsp" }, - { name = "buffer" }, - }, -}) +-- Preview substitutions live, as you type! +vim.opt.inccommand = "split" -local lsp_zero = require("lsp-zero") +-- Show which line your cursor is on +vim.opt.cursorline = true -lsp_zero.on_attach(function(client, bufnr) - lsp_zero.default_keymaps({ buffer = bufnr }) -end) +-- Minimal number of screen lines to keep above and below the cursor. +vim.opt.scrolloff = 10 +vim.g.python3_host_prog = vim.fn.expand("~/.config/nvim/env/neovim-python/bin/python") -lspconfig = require("lspconfig") +-- [[ Basic Keymaps ]] +-- See `:help vim.keymap.set()` -lspconfig.pyright.setup({ - virtual_text = false, -}) +-- Set highlight on search, but clear on pressing in normal mode +vim.opt.hlsearch = true +vim.keymap.set("n", "", "nohlsearch") +vim.keymap.set("n", "-", "Oil", { desc = "Open parent directory" }) +vim.keymap.set("n", "c", '"+y', { noremap = true, silent = true }) +vim.keymap.set("v", "y", '"+y', { noremap = true, silent = true }) +vim.keymap.set("n", "", "dd", { noremap = true, silent = true }) +vim.keymap.set("n", ",d", "DiffviewOpen", { desc = "Repo diff" }) +vim.keymap.set("n", ",hh", "DiffviewFileHistory", { desc = "Repo history" }) +vim.keymap.set("n", ",hf", "DiffviewFileHistory --follow %", { desc = "File history" }) -local capabilities = require("cmp_nvim_lsp").default_capabilities(vim.lsp.protocol.make_client_capabilities()) +function SortCSV() + -- Get the current line + local line = vim.api.nvim_get_current_line() -lspconfig.clangd.setup({ - capabilities = capabilities, -}) + -- Extract the prefix (any --command), quoted part, and trailing comma + local prefix, quoted, trailing = line:match('^(%s*%-%-%w+,%s*)"(.-)"(.-)$') -local configs = require("lspconfig.configs") -if not configs.jinja_lsp then - configs.jinja_lsp = { - default_config = { - cmd = { "/Users/zev/.cargo/bin/jinja-lsp" }, - filetypes = { "jinja", "rs" }, - root_dir = function(fname) - return lspconfig.util.find_git_ancestor(fname) - end, - settings = { - templates = "./templates", - backend = { "./app" }, - lang = "rust", - }, - }, - } + if not prefix or not quoted then + print("Line format not recognized") + return + end + + -- Split the quoted part into a table + local items = vim.split(quoted, ",") + + -- Trim whitespace from each item + for i, item in ipairs(items) do + items[i] = item:match("^%s*(.-)%s*$") + end + + -- Sort the items + table.sort(items) + + -- Join the items back into a quoted string without extra spaces, preserving the trailing comma + local sorted_line = prefix .. '"' .. table.concat(items, ",") .. '"' .. trailing + + -- Replace the current line with the sorted line + vim.api.nvim_set_current_line(sorted_line) end +-- Create a command to call the function +vim.api.nvim_create_user_command("SortCSV", SortCSV, {}) -lspconfig.jinja_lsp.setup({}) -vim.api.nvim_create_augroup("AutoFormat", {}) - -vim.api.nvim_create_autocmd("BufWritePost", { - pattern = "*.py", - group = "AutoFormat", - callback = function() - vim.cmd("silent !black --line-length=120 --quiet %") - vim.cmd("edit") +-- save last position +vim.api.nvim_create_autocmd("BufRead", { + callback = function(opts) + vim.api.nvim_create_autocmd("BufWinEnter", { + once = true, + buffer = opts.buf, + callback = function() + local ft = vim.bo[opts.buf].filetype + local last_known_line = vim.api.nvim_buf_get_mark(opts.buf, '"')[1] + if + not (ft:match("commit") and ft:match("rebase")) + and last_known_line > 1 + and last_known_line <= vim.api.nvim_buf_line_count(opts.buf) + then + vim.api.nvim_feedkeys([[g`"]], "nx", false) + end + end, + }) end, }) -local function on_list(options) - vim.fn.setqflist({}, " ", options) - vim.api.nvim_command("cfirst") -end +-- Diagnostic keymaps +vim.keymap.set("n", "[d", vim.diagnostic.goto_prev, { desc = "Go to previous [D]iagnostic message" }) +vim.keymap.set("n", "]d", vim.diagnostic.goto_next, { desc = "Go to next [D]iagnostic message" }) +vim.keymap.set("n", "e", vim.diagnostic.open_float, { desc = "Show diagnostic [E]rror messages" }) +-- vim.keymap.set('n', 'q', vim.diagnostic.setloclist, { desc = 'Open diagnostic [Q]uickfix list' }) -local bufopts = { noremap = true, silent = true, buffer = bufnr } -vim.keymap.set("n", "d", function() - vim.lsp.buf.definition({ on_list = on_list }) -end, bufopts) -vim.keymap.set("n", "r", function() - vim.lsp.buf.references(nil, { on_list = on_list }) -end, bufopts) +vim.keymap.set("n", "", "w", { desc = "Save" }) +-- save all buffers and quit +vim.keymap.set("n", "q", "wqa", { desc = "Save and Quit" }) +vim.keymap.set("n", "", "bp", { desc = "Prev Buffer" }) +vim.keymap.set("n", "", "bn", { desc = "Next Buffer" }) +vim.keymap.set("n", "w", "write|bdelete", { desc = "Save and close" }) +-- Function to go to the next item in the quickfix list +vim.keymap.set("n", "]n", ":cnext", { noremap = true, silent = true }) + +-- Function to go to the previous item in the quickfix list +vim.keymap.set("n", "[n", ":cprev", { noremap = true, silent = true }) +-- Visual mode mappings +vim.keymap.set("v", "", ":m '<-2gv=gv", { noremap = true, silent = true }) +vim.keymap.set("v", "", ":m '>+1gv=gv", { noremap = true, silent = true }) + +-- Normal mode mappings +vim.keymap.set("n", "", ":m -2", { noremap = true, silent = true }) +vim.keymap.set("n", "", ":m +1", { noremap = true, silent = true }) + +-- Exit terminal mode in the builtin terminal with a shortcut that is a bit easier +-- for people to discover. Otherwise, you normally need to press , which +-- is not what someone will guess without a bit more experience. +-- +-- NOTE: This won't work in all terminal emulators/tmux/etc. Try your own mapping +-- or just use to exit terminal mode +vim.keymap.set("t", "", "", { desc = "Exit terminal mode" }) + +vim.keymap.set("n", "v", "e ~/.config/nvim/init.lua", { desc = "open init.lua" }) + +-- [[ Basic Autocommands ]] +-- See `:help lua-guide-autocommands` + +-- Highlight when yanking (copying) text +vim.api.nvim_create_autocmd("TextYankPost", { + desc = "Highlight when yanking (copying) text", + group = vim.api.nvim_create_augroup("kickstart-highlight-yank", { clear = true }), + callback = function() + vim.highlight.on_yank() + end, +}) + +-- [[ Install `lazy.nvim` plugin manager ]] +local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" +if not vim.loop.fs_stat(lazypath) then + local lazyrepo = "https://github.com/folke/lazy.nvim.git" + vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath }) +end ---@diagnostic disable-next-line: undefined-field +vim.opt.rtp:prepend(lazypath) + +-- [[ Configure and install plugins ]] +-- +-- To check the current status of your plugins, run +-- :Lazy +-- +-- You can press `?` in this menu for help. Use `:q` to close the window +-- +-- To update plugins you can run +-- :Lazy update +-- +-- NOTE: Here is where you install your plugins. +require("lazy").setup({ + -- NOTE: Plugins can be added with a link (or for a github repo: 'owner/repo' link). + "tpope/vim-sleuth", -- Detect tabstop and shiftwidth automatically + "sindrets/diffview.nvim", + "github/copilot.vim", + "junegunn/limelight.vim", + "junegunn/goyo.vim", + { + "stevearc/oil.nvim", + opts = {}, + -- Optional dependencies + dependencies = { "nvim-tree/nvim-web-devicons" }, + }, + + -- NOTE: Plugins can also be added by using a table, + -- with the first argument being the link and the following + -- keys can be used to configure plugin behavior/loading/etc. + -- + -- Use `opts = {}` to force a plugin to be loaded. + -- + -- This is equivalent to: + -- require('Comment').setup({}) + + -- "gc" to comment visual regions/lines + { "numToStr/Comment.nvim", opts = {} }, + + -- Here is a more advanced example where we pass configuration + -- options to `gitsigns.nvim`. This is equivalent to the following Lua: + -- require('gitsigns').setup({ ... }) + -- + -- See `:help gitsigns` to understand what the configuration keys do + { -- Adds git related signs to the gutter, as well as utilities for managing changes + "lewis6991/gitsigns.nvim", + opts = { + signs = { + add = { text = "+" }, + change = { text = "~" }, + delete = { text = "_" }, + topdelete = { text = "‾" }, + changedelete = { text = "~" }, + }, + }, + }, + + -- NOTE: Plugins can also be configured to run Lua code when they are loaded. + -- + -- This is often very useful to both group configuration, as well as handle + -- lazy loading plugins that don't need to be loaded immediately at startup. + -- + -- For example, in the following configuration, we use: + -- event = 'VimEnter' + -- + + -- NOTE: Plugins can specify dependencies. + -- + -- The dependencies are proper plugin specifications as well - anything + -- you do for a plugin at the top level, you can do for a dependency. + -- + -- Use the `dependencies` key to specify the dependencies of a particular plugin + + { -- Fuzzy Finder (files, lsp, etc) + "nvim-telescope/telescope.nvim", + event = "VimEnter", + branch = "0.1.x", + dependencies = { + "nvim-lua/plenary.nvim", + { -- If encountering errors, see telescope-fzf-native README for installation instructions + "nvim-telescope/telescope-fzf-native.nvim", + + -- `build` is used to run some command when the plugin is installed/updated. + -- This is only run then, not every time Neovim starts up. + build = "make", + + -- `cond` is a condition used to determine whether this plugin should be + -- installed and loaded. + cond = function() + return vim.fn.executable("make") == 1 + end, + }, + { "nvim-telescope/telescope-ui-select.nvim" }, + + -- Useful for getting pretty icons, but requires a Nerd Font. + { "nvim-tree/nvim-web-devicons", enabled = vim.g.have_nerd_font }, + }, + config = function() + -- Telescope is a fuzzy finder that comes with a lot of different things that + -- it can fuzzy find! It's more than just a "file finder", it can search + -- many different aspects of Neovim, your workspace, LSP, and more! + -- + -- The easiest way to use Telescope, is to start by doing something like: + -- :Telescope help_tags + -- + -- After running this command, a window will open up and you're able to + -- type in the prompt window. You'll see a list of `help_tags` options and + -- a corresponding preview of the help. + -- + -- Two important keymaps to use while in Telescope are: + -- - Insert mode: + -- - Normal mode: ? + -- + -- This opens a window that shows you all of the keymaps for the current + -- Telescope picker. This is really useful to discover what Telescope can + -- do as well as how to actually do it! + + -- [[ Configure Telescope ]] + -- See `:help telescope` and `:help telescope.setup()` + require("telescope").setup({ + -- You can put your default mappings / updates / etc. in here + -- All the info you're looking for is in `:help telescope.setup()` + -- + -- defaults = { + -- mappings = { + -- i = { [''] = 'to_fuzzy_refine' }, + -- }, + -- }, + -- pickers = {} + extensions = { + ["ui-select"] = { + require("telescope.themes").get_dropdown(), + }, + }, + }) + + -- Enable Telescope extensions if they are installed + pcall(require("telescope").load_extension, "fzf") + pcall(require("telescope").load_extension, "ui-select") + + -- See `:help telescope.builtin` + local builtin = require("telescope.builtin") + vim.keymap.set("n", "f", builtin.find_files, { desc = "[S]earch [F]iles" }) + vim.keymap.set("n", "g", builtin.live_grep, { desc = "[S]earch by [G]rep" }) + vim.keymap.set("n", "d", builtin.diagnostics, { desc = "[S]earch [D]iagnostics" }) + vim.keymap.set("n", "sr", builtin.resume, { desc = "[S]earch [R]esume" }) + vim.keymap.set("n", "", builtin.buffers, { desc = "[ ] Find existing buffers" }) + + -- -- Slightly advanced example of overriding default behavior and theme + -- vim.keymap.set('n', '/', function() + -- -- You can pass additional configuration to Telescope to change the theme, layout, etc. + -- builtin.current_buffer_fuzzy_find(require('telescope.themes').get_dropdown { + -- winblend = 10, + -- previewer = false, + -- }) + -- end, { desc = '[/] Fuzzily search in current buffer' }) + -- + -- It's also possible to pass additional configuration options. + -- See `:help telescope.builtin.live_grep()` for information about particular keys + + -- vim.keymap.set('n', 's/', function() + -- builtin.live_grep { + -- grep_open_files = true, + -- prompt_title = 'Live Grep in Open Files', + -- } + -- end, { desc = '[S]earch [/] in Open Files' }) + -- + -- Shortcut for searching your Neovim configuration files + -- vim.keymap.set('n', 'sn', function() + -- builtin.find_files { cwd = vim.fn.stdpath 'config' } + -- end, { desc = '[S]earch [N]eovim files' }) + end, + }, + + { -- LSP Configuration & Plugins + "neovim/nvim-lspconfig", + dependencies = { + -- Automatically install LSPs and related tools to stdpath for Neovim + { "williamboman/mason.nvim", config = true }, -- NOTE: Must be loaded before dependants + "williamboman/mason-lspconfig.nvim", + "WhoIsSethDaniel/mason-tool-installer.nvim", + + -- Useful status updates for LSP. + -- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})` + { "j-hui/fidget.nvim", opts = {} }, + + -- `neodev` configures Lua LSP for your Neovim config, runtime and plugins + -- used for completion, annotations and signatures of Neovim apis + { "folke/neodev.nvim", opts = {} }, + }, + config = function() + -- Brief aside: **What is LSP?** + -- + -- LSP is an initialism you've probably heard, but might not understand what it is. + -- + -- LSP stands for Language Server Protocol. It's a protocol that helps editors + -- and language tooling communicate in a standardized fashion. + -- + -- In general, you have a "server" which is some tool built to understand a particular + -- language (such as `gopls`, `lua_ls`, `rust_analyzer`, etc.). These Language Servers + -- (sometimes called LSP servers, but that's kind of like ATM Machine) are standalone + -- processes that communicate with some "client" - in this case, Neovim! + -- + -- LSP provides Neovim with features like: + -- - Go to definition + -- - Find references + -- - Autocompletion + -- - Symbol Search + -- - and more! + -- + -- Thus, Language Servers are external tools that must be installed separately from + -- Neovim. This is where `mason` and related plugins come into play. + -- + -- If you're wondering about lsp vs treesitter, you can check out the wonderfully + -- and elegantly composed help section, `:help lsp-vs-treesitter` + + -- This function gets run when an LSP attaches to a particular buffer. + -- That is to say, every time a new file is opened that is associated with + -- an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this + -- function will be executed to configure the current buffer + vim.api.nvim_create_autocmd("LspAttach", { + group = vim.api.nvim_create_augroup("kickstart-lsp-attach", { clear = true }), + callback = function(event) + -- NOTE: Remember that Lua is a real programming language, and as such it is possible + -- to define small helper and utility functions so you don't have to repeat yourself. + -- + -- In this case, we create a function that lets us more easily define mappings specific + -- for LSP related items. It sets the mode, buffer and description for us each time. + local map = function(keys, func, desc) + vim.keymap.set("n", keys, func, { buffer = event.buf, desc = "LSP: " .. desc }) + end + + -- Jump to the definition of the word under your cursor. + -- This is where a variable was first declared, or where a function is defined, etc. + -- To jump back, press . + map("gd", require("telescope.builtin").lsp_definitions, "[G]oto [D]efinition") + + -- Find references for the word under your cursor. + map("r", require("telescope.builtin").lsp_references, "[G]oto [R]eferences") + + -- Jump to the implementation of the word under your cursor. + -- Useful when your language has ways of declaring types without an actual implementation. + -- map('gI', require('telescope.builtin').lsp_implementations, '[G]oto [I]mplementation') + + -- Jump to the type of the word under your cursor. + -- Useful when you're not sure what type a variable is and you want to see + -- the definition of its *type*, not where it was *defined*. + map("t", require("telescope.builtin").lsp_type_definitions, "Type [D]efinition") + + -- Fuzzy find all the symbols in your current document. + -- Symbols are things like variables, functions, types, etc. + map("s", require("telescope.builtin").lsp_document_symbols, "[D]ocument [S]ymbols") + + -- Rename the variable under your cursor. + -- Most Language Servers support renaming across files, etc. + map("n", vim.lsp.buf.rename, "Re[n]ame") + + -- Execute a code action, usually your cursor needs to be on top of an error + -- or a suggestion from your LSP for this to activate. + map("a", vim.lsp.buf.code_action, "Code [A]ction") + + -- Opens a popup that displays documentation about the word under your cursor + -- See `:help K` for why this keymap. + map("K", vim.lsp.buf.hover, "Hover Documentation") + + -- This is not Goto Definition, this is Goto Declaration. + -- For example, in C this would take you to the header. + -- map('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration') + + -- The following two autocommands are used to highlight references of the + -- word under your cursor when your cursor rests there for a little while. + -- See `:help CursorHold` for information about when this is executed + -- + -- When you move your cursor, the highlights will be cleared (the second autocommand). + local client = vim.lsp.get_client_by_id(event.data.client_id) + if client and client.server_capabilities.documentHighlightProvider then + local highlight_augroup = + vim.api.nvim_create_augroup("kickstart-lsp-highlight", { clear = false }) + vim.api.nvim_create_autocmd({ "CursorHold", "CursorHoldI" }, { + buffer = event.buf, + group = highlight_augroup, + callback = vim.lsp.buf.document_highlight, + }) + + vim.api.nvim_create_autocmd({ "CursorMoved", "CursorMovedI" }, { + buffer = event.buf, + group = highlight_augroup, + callback = vim.lsp.buf.clear_references, + }) + + vim.api.nvim_create_autocmd("LspDetach", { + group = vim.api.nvim_create_augroup("kickstart-lsp-detach", { clear = true }), + callback = function(event2) + vim.lsp.buf.clear_references() + vim.api.nvim_clear_autocmds({ group = "kickstart-lsp-highlight", buffer = event2.buf }) + end, + }) + end + + -- The following autocommand is used to enable inlay hints in your + -- code, if the language server you are using supports them + -- + -- This may be unwanted, since they displace some of your code + if client and client.server_capabilities.inlayHintProvider and vim.lsp.inlay_hint then + map("th", function() + vim.lsp.inlay_hint.enable(false, nil) + end, "[T]oggle Inlay [H]ints") + end + end, + }) + + -- LSP servers and clients are able to communicate to each other what features they support. + -- By default, Neovim doesn't support everything that is in the LSP specification. + -- When you add nvim-cmp, luasnip, etc. Neovim now has *more* capabilities. + -- So, we create new capabilities with nvim cmp, and then broadcast that to the servers. + local capabilities = vim.lsp.protocol.make_client_capabilities() + capabilities = vim.tbl_deep_extend("force", capabilities, require("cmp_nvim_lsp").default_capabilities()) + + -- Enable the following language servers + -- Feel free to add/remove any LSPs that you want here. They will automatically be installed. + -- + -- Add any additional override configuration in the following tables. Available keys are: + -- - cmd (table): Override the default command used to start the server + -- - filetypes (table): Override the default list of associated filetypes for the server + -- - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features. + -- - settings (table): Override the default settings passed when initializing the server. + -- For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/ + local servers = { + pyright = { + settings = { + python = { + analysis = { + diagnosticSeverityOverrides = { + reportImplicitStringConcatenation = "warning", + }, + }, + }, + }, + }, + -- ... etc. See `:help lspconfig-all` for a list of all the pre-configured LSPs + -- + -- Some languages (like typescript) have entire language plugins that can be useful: + -- https://github.com/pmizio/typescript-tools.nvim + -- + -- But for many setups, the LSP (`tsserver`) will work just fine + ts_ls = {}, + html = {}, + tailwindcss = {}, + css_variables = {}, + + lua_ls = { + -- cmd = {...}, + -- filetypes = { ...}, + -- capabilities = {}, + settings = { + Lua = { + completion = { + callSnippet = "Replace", + }, + -- You can toggle below to ignore Lua_LS's noisy `missing-fields` warnings + -- diagnostics = { disable = { 'missing-fields' } }, + }, + }, + }, + } + + -- Ensure the servers and tools above are installed + -- To check the current status of installed tools and/or manually install + -- other tools, you can run + -- :Mason + -- + -- You can press `g?` for help in this menu. + require("mason").setup() + + -- You can add other tools here that you want Mason to install + -- for you, so that they are available from within Neovim. + local ensure_installed = vim.tbl_keys(servers or {}) + vim.list_extend(ensure_installed, { + "stylua", -- Used to format Lua code + }) + require("mason-tool-installer").setup({ ensure_installed = ensure_installed }) + + require("mason-lspconfig").setup({ + handlers = { + function(server_name) + local server = servers[server_name] or {} + -- This handles overriding only values explicitly passed + -- by the server configuration above. Useful when disabling + -- certain features of an LSP (for example, turning off formatting for tsserver) + server.capabilities = vim.tbl_deep_extend("force", {}, capabilities, server.capabilities or {}) + require("lspconfig")[server_name].setup(server) + end, + }, + }) + end, + }, + + { -- Autoformat + "stevearc/conform.nvim", + lazy = false, + opts = { + notify_on_error = false, + format_on_save = function(bufnr) + -- Disable "format_on_save lsp_fallback" for languages that don't + -- have a well standardized coding style. You can add additional + -- languages here or re-enable it for the disabled ones. + local disable_filetypes = { c = true, cpp = true, python = true } + return { + timeout_ms = 2500, + lsp_fallback = not disable_filetypes[vim.bo[bufnr].filetype], + } + end, + log_level = vim.log.levels.DEBUG, + formatters = { + prettier = { + command = "prettier", + args = { "--stdin-filepath", "$FILENAME" }, + stdin = true, + }, + black = { + prepend_args = { "--line-length", "120" }, + }, + }, + formatters_by_ft = { + lua = { "stylua" }, + javascript = { "prettierd", "prettier" }, + typescript = { "prettierd", "prettier" }, + typescriptreact = { "prettierd", "prettier" }, + python = { "black" }, -- Add this line for Python formatting + }, + }, + }, + + { -- Autocompletion + "hrsh7th/nvim-cmp", + event = "InsertEnter", + dependencies = { + -- Snippet Engine & its associated nvim-cmp source + { + "L3MON4D3/LuaSnip", + build = (function() + -- Build Step is needed for regex support in snippets. + -- This step is not supported in many windows environments. + -- Remove the below condition to re-enable on windows. + if vim.fn.has("win32") == 1 or vim.fn.executable("make") == 0 then + return + end + return "make install_jsregexp" + end)(), + dependencies = { + -- `friendly-snippets` contains a variety of premade snippets. + -- See the README about individual language/framework/plugin snippets: + -- https://github.com/rafamadriz/friendly-snippets + -- { + -- 'rafamadriz/friendly-snippets', + -- config = function() + -- require('luasnip.loaders.from_vscode').lazy_load() + -- end, + -- }, + }, + }, + "saadparwaiz1/cmp_luasnip", + + -- Adds other completion capabilities. + -- nvim-cmp does not ship with all sources by default. They are split + -- into multiple repos for maintenance purposes. + "hrsh7th/cmp-nvim-lsp", + "hrsh7th/cmp-path", + }, + config = function() + -- See `:help cmp` + local cmp = require("cmp") + local luasnip = require("luasnip") + luasnip.config.setup({}) + + cmp.setup({ + snippet = { + expand = function(args) + luasnip.lsp_expand(args.body) + end, + }, + completion = { completeopt = "menu,menuone,noinsert" }, + + -- For an understanding of why these mappings were + -- chosen, you will need to read `:help ins-completion` + -- + -- No, but seriously. Please read `:help ins-completion`, it is really good! + mapping = cmp.mapping.preset.insert({ + -- Select the [n]ext item + [""] = cmp.mapping.select_next_item(), + -- Select the [p]revious item + [""] = cmp.mapping.select_prev_item(), + + -- Scroll the documentation window [b]ack / [f]orward + [""] = cmp.mapping.scroll_docs(-4), + [""] = cmp.mapping.scroll_docs(4), + + -- Accept ([y]es) the completion. + -- This will auto-import if your LSP supports it. + -- This will expand snippets if the LSP sent a snippet. + [""] = cmp.mapping.confirm({ select = true }), + + -- If you prefer more traditional completion keymaps, + -- you can uncomment the following lines + --[''] = cmp.mapping.confirm { select = true }, + --[''] = cmp.mapping.select_next_item(), + --[''] = cmp.mapping.select_prev_item(), + + -- Manually trigger a completion from nvim-cmp. + -- Generally you don't need this, because nvim-cmp will display + -- completions whenever it has completion options available. + [""] = cmp.mapping.complete({}), + + -- Think of as moving to the right of your snippet expansion. + -- So if you have a snippet that's like: + -- function $name($args) + -- $body + -- end + -- + -- will move you to the right of each of the expansion locations. + -- is similar, except moving you backwards. + [""] = cmp.mapping(function() + if luasnip.expand_or_locally_jumpable() then + luasnip.expand_or_jump() + end + end, { "i", "s" }), + [""] = cmp.mapping(function() + if luasnip.locally_jumpable(-1) then + luasnip.jump(-1) + end + end, { "i", "s" }), + + -- For more advanced Luasnip keymaps (e.g. selecting choice nodes, expansion) see: + -- https://github.com/L3MON4D3/LuaSnip?tab=readme-ov-file#keymaps + }), + sources = { + { name = "nvim_lsp" }, + { name = "luasnip" }, + { name = "path" }, + }, + }) + end, + }, + + { -- You can easily change to a different colorscheme. + -- Change the name of the colorscheme plugin below, and then + -- change the command in the config to whatever the name of that colorscheme is. + -- + -- If you want to see what colorschemes are already installed, you can use `:Telescope colorscheme`. + "catppuccin/nvim", + priority = 1000, -- Make sure to load this before all the other start plugins. + init = function() + -- Load the colorscheme here. + -- Like many other themes, this one has different styles, and you could load + -- any other, such as 'tokyonight-storm', 'tokyonight-moon', or 'tokyonight-day'. + vim.cmd.colorscheme("catppuccin-mocha") + -- vim.cmd.colorscheme 'catppuccin-latte' + + -- You can configure highlights by doing something like: + vim.cmd.hi("Comment gui=none") + end, + }, + + -- Highlight todo, notes, etc in comments + { + "folke/todo-comments.nvim", + event = "VimEnter", + dependencies = { "nvim-lua/plenary.nvim" }, + opts = { signs = false }, + }, + + { -- Collection of various small independent plugins/modules + "echasnovski/mini.nvim", + config = function() + -- Better Around/Inside textobjects + -- + -- Examples: + -- - va) - [V]isually select [A]round [)]paren + -- - yinq - [Y]ank [I]nside [N]ext [']quote + -- - ci' - [C]hange [I]nside [']quote + require("mini.ai").setup({ n_lines = 500 }) + + -- Add/delete/replace surroundings (brackets, quotes, etc.) + -- + -- - saiw) - [S]urround [A]dd [I]nner [W]ord [)]Paren + -- - sd' - [S]urround [D]elete [']quotes + -- - sr)' - [S]urround [R]eplace [)] ['] + require("mini.surround").setup() + + -- Simple and easy statusline. + -- You could remove this setup call if you don't like it, + -- and try some other statusline plugin + local statusline = require("mini.statusline") + -- set use_icons to true if you have a Nerd Font + statusline.setup({ use_icons = vim.g.have_nerd_font }) + + -- You can configure sections in the statusline by overriding their + -- default behavior. For example, here we set the section for + -- cursor location to LINE:COLUMN + ---@diagnostic disable-next-line: duplicate-set-field + statusline.section_location = function() + return "%2l:%-2v" + end + + -- ... and there is more! + -- Check out: https://github.com/echasnovski/mini.nvim + end, + }, + { -- Highlight, edit, and navigate code + "nvim-treesitter/nvim-treesitter", + build = ":TSUpdate", + opts = { + ensure_installed = { "bash", "c", "diff", "html", "lua", "luadoc", "markdown", "vim", "vimdoc" }, + -- Autoinstall languages that are not installed + auto_install = true, + highlight = { + enable = true, + -- Some languages depend on vim's regex highlighting system (such as Ruby) for indent rules. + -- If you are experiencing weird indenting issues, add the language to + -- the list of additional_vim_regex_highlighting and disabled languages for indent. + additional_vim_regex_highlighting = { "ruby" }, + }, + indent = { enable = true, disable = { "ruby" } }, + }, + config = function(_, opts) + -- [[ Configure Treesitter ]] See `:help nvim-treesitter` + + -- Prefer git instead of curl in order to improve connectivity in some environments + require("nvim-treesitter.install").prefer_git = true + ---@diagnostic disable-next-line: missing-fields + require("nvim-treesitter.configs").setup(opts) + + -- There are additional nvim-treesitter modules that you can use to interact + -- with nvim-treesitter. You should go explore a few and see what interests you: + -- + -- - Incremental selection: Included, see `:help nvim-treesitter-incremental-selection-mod` + -- - Show your current context: https://github.com/nvim-treesitter/nvim-treesitter-context + -- - Treesitter + textobjects: https://github.com/nvim-treesitter/nvim-treesitter-textobjects + end, + }, + + -- The following two comments only work if you have downloaded the kickstart repo, not just copy pasted the + -- init.lua. If you want these files, they are in the repository, so you can just download them and + -- place them in the correct locations. + + -- NOTE: Next step on your Neovim journey: Add/Configure additional plugins for Kickstart + -- + -- Here are some example plugins that I've included in the Kickstart repository. + -- Uncomment any of the lines below to enable them (you will need to restart nvim). + -- + -- require 'kickstart.plugins.debug', + -- require 'kickstart.plugins.indent_line', + -- require 'kickstart.plugins.lint', + -- require 'kickstart.plugins.autopairs', + -- require 'kickstart.plugins.neo-tree', + -- require 'kickstart.plugins.gitsigns', -- adds gitsigns recommend keymaps + + -- NOTE: The import below can automatically add your own plugins, configuration, etc from `lua/custom/plugins/*.lua` + -- This is the easiest way to modularize your config. + -- + -- Uncomment the following line and add your plugins to `lua/custom/plugins/*.lua` to get going. + -- For additional information, see `:help lazy.nvim-lazy.nvim-structuring-your-plugins` + -- { import = 'custom.plugins' }, +}, { + ui = { + -- If you are using a Nerd Font: set icons to an empty table which will use the + -- default lazy.nvim defined Nerd Font icons, otherwise define a unicode icons table + icons = vim.g.have_nerd_font and {} or { + cmd = "⌘", + config = "🛠", + event = "📅", + ft = "📂", + init = "⚙", + keys = "🗝", + plugin = "🔌", + runtime = "💻", + require = "🌙", + source = "📄", + start = "🚀", + task = "📌", + lazy = "💤 ", + }, + }, +}) + +vim.api.nvim_create_autocmd("FileType", { + pattern = "markdown", + callback = function() + vim.cmd("Goyo") + vim.cmd("Limelight") + end, +}) +vim.g.goyo_bg = "light" -- or 'light' depending on your preference + +require("oil").setup({ + natural_order = false, + sort = { + { "ctime", "desc" }, + }, +}) diff --git a/install.sh b/install.sh deleted file mode 100755 index 47022c9..0000000 --- a/install.sh +++ /dev/null @@ -1,6 +0,0 @@ -#!/bin/bash - -ln -s $HOME/repos/dotfiles/tmux.conf $HOME/.tmux.conf -ln -s $HOME/repos/dotfiles/bash_aliases $HOME/.bash_aliases -ln -s $HOME/repos/dotfiles/init.lua $HOME/.config/nvim/init.lua -ln -s $HOME/repos/dotfiles/vimrc.vim $HOME/.config/nvim/vimrc.vim diff --git a/tmux.conf b/tmux.conf index 0a6e60d..96b6eec 100644 --- a/tmux.conf +++ b/tmux.conf @@ -1,34 +1,50 @@ # remap prefix unbind C-b -set-option -g prefix ` -bind-key ` send-prefix - -set -g @plugin 'tmux-plugins/tpm' -set -g @plugin 'tmux-plugins/tmux-resurrect' -set -g @plugin 'tmux-plugins/tmux-continuum' -set -g @continuum-restore 'on' -set -g @continuum-save-interval '1' - +set -g prefix ` +bind ` send-prefix set -g mouse on set -g pane-border-style fg=black -set-option -sg escape-time 10 -set-option -g focus-events on -set-option -g default-terminal "screen-256color" -set-option -ga terminal-overrides ',xterm-256color:Tc' -set-option -g history-limit 30000 -set-window-option -g aggressive-resize +set -g @sessionx-bind 'o' +set -g @sessionx-bind 's' +bind l select-pane -t :.+ +bind h select-pane -t :.- + +unbind-key -T copy-mode-vi v + setw -g mode-keys vi -bind-key -T copy-mode-vi y send -X copy-selection-and-cancel -bind -T copy-mode-vi v send -X begin-selection +bind -T copy-mode-vi 'r' send -X rectangle-toggle # Begin selection in copy mode. +bind -T copy-mode-vi 'v' send -X begin-selection # Begin selection in copy mode. +bind -T copy-mode-vi 'y' send -X copy-selection # Yank selection in copy mode. bind P paste-buffer -bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel +bind -T root C-c if-shell -F '#{==:#{pane_mode},tree-mode}' 'send-keys Escape' 'send-keys C-c' +bind c new-window -c "#{pane_current_path}" +bind '"' split-window -c "#{pane_current_path}" +bind % split-window -h -c "#{pane_current_path}" -# bind ctrl-C to escape -bind-key -n C-c send-keys Escape +set -sg escape-time 10 +set -g focus-events on +set -g default-terminal "screen-256color" +set -ga terminal-overrides ',xterm-256color:Tc' +set -g history-limit 30000 +set-window-option -g aggressive-resize +# set -ag pane-active-border fg=magenta +set -g status on +set -g status-left "" +set -g status-right "#{session_name}" +set -g status-style bg=colour17,fg=colour248 +set -g window-status-format "" +set -g window-status-current-format "" +set -g status-interval 1 +set -g status-position bottom +set -g status-right-length 50 +set -g display-time 200 +set -g message-style bg=default,fg=default +set -g @plugin 'tmux-plugins/tpm' +set -g @plugin 'tmux-plugins/tmux-sensible' +set -g @plugin 'omerxx/tmux-sessionx' run '~/.tmux/plugins/tpm/tpm' -# run-shell ~/clone/path/continuum.tmux diff --git a/vimrc.vim b/vimrc.vim deleted file mode 100644 index bf8538b..0000000 --- a/vimrc.vim +++ /dev/null @@ -1,70 +0,0 @@ -set autoindent expandtab tabstop=4 shiftwidth=4 -set hidden -let g:python3_host_prog = '/usr/local/vitol/pyenv/versions/3.11.4/bin/python' - - -" When editing a file, always jump to the last known cursor position. -autocmd BufReadPost * - \ if line("'\"") >= 1 && line("'\"") <= line("$") && &ft !~# 'commit' - \ | exe "normal! g`\"" - \ | endif - -nnoremap :w -nnoremap :bn -nnoremap :bp -inoremap :wi -let mapleader=" " -nnoremap w :w:bw -nnoremap W :bw -nnoremap v :e ~/.config/nvim/init.lua -nnoremap m :e ~/.config/nvim/vimrc.vim -nnoremap s :source ~/.config/nvim/init.lua -nnoremap q :xa -nnoremap f Telescope find_files -nnoremap g Telescope live_grep -nnoremap b Telescope buffers -nnoremap h Telescope help_tags -nnoremap l Lazy -nmap j (coc-diagnostic-prev) -nmap d (coc-diagnostic-next) -function! s:c_cycle(count) abort - let qf_info = getqflist({ 'idx': 0, 'size': 0 }) - let size = qf_info->get('size') - if size == 0 - return - endif - - let idx = qf_info->get('idx') - - let num = (idx + size + a:count) % size - - if num == 0 - let num = size - endif - - execute num .. 'cc' -endfunction -command! -nargs=1 CCycle call s:c_cycle() - -nnoremap [n 'CCycle -' .. v:count1 .. '' -nnoremap ]n 'CCycle ' .. v:count1 .. '' - -vnoremap :m '<-2gv=gv -vnoremap :m '>+1gv=gv -nnoremap :m -2 -nnoremap :m +1 -map gf :e - -augroup tokyonight-night - autocmd! - autocmd ColorScheme * highlight Normal guibg=NONE ctermbg=NONE - autocmd ColorScheme * highlight NonText guibg=NONE ctermbg=NONE -augroup END -colorscheme tokyonight-night -set background=dark - -let g:LanguageClient_useVirtualText = 0 " disable inline errors - -set undodir=~/.config/nvim/undodir -set undofile -set number relativenumber