diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 00000000..8b176d56 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,7 @@ +root = true + +[*] +insert_final_newline = true +indent_style = space +indent_size = 2 +charset = utf-8 diff --git a/.github/.release-please-manifest.json b/.github/.release-please-manifest.json new file mode 100644 index 00000000..b9d0dcaf --- /dev/null +++ b/.github/.release-please-manifest.json @@ -0,0 +1,3 @@ +{ + ".": "12.38.2" +} diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml index 03fbd8ca..16bf6ed1 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.yml +++ b/.github/ISSUE_TEMPLATE/bug_report.yml @@ -6,7 +6,10 @@ body: - type: markdown attributes: value: | - **Before** reporting an issue, make sure to read the [documentation](https://github.com/folke/LazyVim) and search [existing issues](https://github.com/folke/LazyVim/issues). Usage questions such as ***"How do I...?"*** belong in [Discussions](https://github.com/folke/LazyVim/discussions) and will be closed. + **Before** reporting an issue, make sure to read the [documentation](https://github.com/LazyVim/LazyVim) + and search [existing issues](https://github.com/LazyVim/LazyVim/issues). + + Usage questions such as ***"How do I...?"*** belong in [Discussions](https://github.com/LazyVim/LazyVim/discussions) and will be closed. - type: checkboxes attributes: label: Did you check docs and existing issues? @@ -14,6 +17,8 @@ body: options: - label: I have read all the LazyVim docs required: true + - label: I have updated the plugin to the latest version before submitting this issue + required: true - label: I have searched the existing issues of LazyVim required: true - label: I have searched the existing issues of plugins related to this issue @@ -57,33 +62,15 @@ body: label: Repro description: Minimal `init.lua` to reproduce this issue. Save as `repro.lua` and run with `nvim -u repro.lua` value: | - -- DO NOT change the paths and don't remove the colorscheme - local root = vim.fn.fnamemodify("./.repro", ":p") + vim.env.LAZY_STDPATH = ".repro" + load(vim.fn.system("curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua"))() - -- set stdpaths to use .repro - for _, name in ipairs({ "config", "data", "state", "cache" }) do - vim.env[("XDG_%s_HOME"):format(name:upper())] = root .. "/" .. name - end - - -- bootstrap lazy - local lazypath = root .. "/plugins/lazy.nvim" - if not vim.loop.fs_stat(lazypath) then - vim.fn.system({ "git", "clone", "--filter=blob:none", "https://github.com/folke/lazy.nvim.git", lazypath, }) - end - vim.opt.runtimepath:prepend(lazypath) - - -- install plugins - local plugins = { - "folke/tokyonight.nvim", - "folke/LazyVim", - -- add any other plugins here - } - require("lazy").setup(plugins, { - root = root .. "/plugins", + require("lazy.minit").repro({ + spec = { + { "LazyVim/LazyVim", import = "lazyvim.plugins" }, + -- add any other plugins here + }, }) - - vim.cmd.colorscheme("tokyonight") - -- add anything else here - render: Lua + render: lua validations: required: false diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml index f861a282..1534cf54 100644 --- a/.github/ISSUE_TEMPLATE/config.yml +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -1,5 +1,5 @@ blank_issues_enabled: false contact_links: - - name: Ask a question or start a discussion + - name: Ask a question url: https://github.com/LazyVim/LazyVim/discussions about: Use Github discussions instead diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index c1b3225d..c1e6f982 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -1,15 +1,19 @@ -## What is this PR for? +## Description -## Does this PR fix an existing issue? +## Related Issue(s) +## Screenshots + + + ## Checklist - [ ] I've read the [CONTRIBUTING](https://github.com/LazyVim/LazyVim/blob/main/CONTRIBUTING.md) guidelines. diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 0d08e261..5ace4600 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -1,11 +1,6 @@ -# To get started with Dependabot version updates, you'll need to specify which -# package ecosystems to update and where the package manifests are located. -# Please see the documentation for all configuration options: -# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file - version: 2 updates: - - package-ecosystem: "github-actions" # See documentation for possible values - directory: "/" # Location of package manifests + - package-ecosystem: "github-actions" + directory: "/" schedule: interval: "weekly" diff --git a/.github/release-please-config.json b/.github/release-please-config.json new file mode 100644 index 00000000..41fccb15 --- /dev/null +++ b/.github/release-please-config.json @@ -0,0 +1,9 @@ +{ + "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json", + "packages": { + ".": { + "release-type": "simple", + "extra-files": ["lua/lazyvim/config/init.lua"] + } + } +} diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index fddf82ac..96993304 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,81 +1,14 @@ name: CI + on: push: + branches: [main, master] pull_request: jobs: - stylua: - name: Stylua Formatting - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - uses: JohnnyMorganz/stylua-action@v4 - with: - token: ${{ secrets.GITHUB_TOKEN }} - version: latest - args: --check . - tests: - strategy: - matrix: - # os: [ubuntu-latest, windows-latest] - os: [ubuntu-latest] - runs-on: ${{ matrix.os }} - steps: - - uses: actions/checkout@v4 - - name: Install Neovim - shell: bash - run: | - mkdir -p /tmp/nvim - wget -q https://github.com/neovim/neovim/releases/download/nightly/nvim.appimage -O /tmp/nvim/nvim.appimage - cd /tmp/nvim - chmod a+x ./nvim.appimage - ./nvim.appimage --appimage-extract - echo "/tmp/nvim/squashfs-root/usr/bin/" >> $GITHUB_PATH - - name: Run Tests - run: | - nvim --version - [ ! -d tests ] && exit 0 - ./tests/run - docs: - runs-on: ubuntu-latest - needs: tests - if: ${{ github.ref == 'refs/heads/main' }} - steps: - - uses: actions/checkout@v4 - - name: panvimdoc - uses: kdheepak/panvimdoc@main - with: - vimdoc: LazyVim - version: "Neovim >= 0.9.0" - demojify: true - treesitter: true - - name: Push changes - uses: stefanzweifel/git-auto-commit-action@v5 - with: - commit_message: "chore(build): auto-generate vimdoc" - commit_user_name: "github-actions[bot]" - commit_user_email: "github-actions[bot]@users.noreply.github.com" - commit_author: "github-actions[bot] " - release: - name: release - if: ${{ github.ref == 'refs/heads/main' }} - needs: - - docs - - tests - runs-on: ubuntu-latest - steps: - - uses: googleapis/release-please-action@v4 - id: release - with: - release-type: simple - - uses: actions/checkout@v4 - - name: tag stable versions - if: ${{ steps.release.outputs.release_created }} - run: | - git config user.name github-actions[bot] - git config user.email github-actions[bot]@users.noreply.github.com - git remote add gh-token "https://${{ secrets.GITHUB_TOKEN }}@github.com/google-github-actions/release-please-action.git" - git tag -d stable || true - git push origin :stable || true - git tag -a stable -m "Last Stable Release" - git push origin stable + ci: + uses: folke/github/.github/workflows/ci.yml@main + secrets: inherit + with: + plugin: LazyVim + repo: LazyVim/LazyVim diff --git a/.github/workflows/labeler.yml b/.github/workflows/labeler.yml index 52474c6a..0908727b 100644 --- a/.github/workflows/labeler.yml +++ b/.github/workflows/labeler.yml @@ -1,12 +1,8 @@ -name: "Pull Request Labeler" +name: "PR Labeler" on: - pull_request_target jobs: labeler: - permissions: - contents: read - pull-requests: write - runs-on: ubuntu-latest - steps: - - uses: actions/labeler@v5 + uses: folke/github/.github/workflows/labeler.yml@main + secrets: inherit diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml index 0401a4d8..6d9df366 100644 --- a/.github/workflows/pr.yml +++ b/.github/workflows/pr.yml @@ -1,4 +1,4 @@ -name: "Lint PR" +name: PR Title on: pull_request_target: @@ -6,36 +6,13 @@ on: - opened - edited - synchronize + - reopened + - ready_for_review permissions: pull-requests: read jobs: - main: - name: Validate PR title - runs-on: ubuntu-latest - steps: - - uses: amannn/action-semantic-pull-request@v5 - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - with: - requireScope: true - subjectPattern: ^(?![A-Z]).+$ - scopes: | - .+ - types: | - build - chore - ci - docs - feat - fix - merge - perf - refactor - revert - style - test - wip - ignoreLabels: | - autorelease: pending + pr-title: + uses: folke/github/.github/workflows/pr.yml@main + secrets: inherit diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml index 9ebbb312..4e0273bc 100644 --- a/.github/workflows/stale.yml +++ b/.github/workflows/stale.yml @@ -1,27 +1,11 @@ -name: Close stale issues and PRs +name: Stale Issues & PRs on: - workflow_dispatch: schedule: - cron: "30 1 * * *" jobs: stale: - runs-on: ubuntu-latest - steps: - - uses: actions/stale@v9 - with: - operations-per-run: 300 - # default stale time - days-before-stale: 30 - days-before-close: 7 - # never stale pull requests - # days-before-pr-stale: -1 - days-before-pr-close: -1 - # exclude issues with certain labels - exempt-issue-labels: pinned,wip,security,notice - # never stale issues attached to a milestone - # exempt-all-milestones: true - stale-issue-message: "This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 7 days." - stale-pr-message: "This PR is stale because it has been open 60 days with no activity." - close-issue-message: "This issue was closed because it has been stalled for 7 days with no activity." + if: contains(fromJSON('["folke", "LazyVim"]'), github.repository_owner) + uses: folke/github/.github/workflows/stale.yml@main + secrets: inherit diff --git a/.github/workflows/update.yml b/.github/workflows/update.yml new file mode 100644 index 00000000..6784ef9c --- /dev/null +++ b/.github/workflows/update.yml @@ -0,0 +1,13 @@ +name: Update Repo + +on: + workflow_dispatch: + schedule: + # Run every hour + - cron: "0 * * * *" + +jobs: + update: + if: contains(fromJSON('["folke", "LazyVim"]'), github.repository_owner) + uses: folke/github/.github/workflows/update.yml@main + secrets: inherit diff --git a/.gitignore b/.gitignore index cc5457ab..771c8351 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,9 @@ -tt.* -.tests -doc/tags -debug -.repro -foo.* *.log -data +/.repro +/.tests +/build +/debug +/doc/tags +foo.* +node_modules +tt.* diff --git a/CHANGELOG.md b/CHANGELOG.md index a0d7187f..9c626d98 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,557 @@ # Changelog +## [12.38.2](https://github.com/LazyVim/LazyVim/compare/v12.38.1...v12.38.2) (2024-07-25) + + +### Bug Fixes + +* **news:** pcall diag when showing news for older Neovim versions ([94bf4f9](https://github.com/LazyVim/LazyVim/commit/94bf4f932482012306fb375c4418a398bb00a949)) + +## [12.38.1](https://github.com/LazyVim/LazyVim/compare/v12.38.0...v12.38.1) (2024-07-24) + + +### Bug Fixes + +* **autcmds:** added grug-far to close with q ([3282721](https://github.com/LazyVim/LazyVim/commit/328272144c8c0b2d96988770d48c690a72613a81)) + +## [12.38.0](https://github.com/LazyVim/LazyVim/compare/v12.37.0...v12.38.0) (2024-07-24) + + +### Features + +* **markdown:** markdown-render toggle ([c8d0faf](https://github.com/LazyVim/LazyVim/commit/c8d0faf9b152283b2ae74f9594287a834eae002a)) +* **markdown:** replace `headlines.nvim` by `markdown.nvim` ([#4139](https://github.com/LazyVim/LazyVim/issues/4139)) ([264abdf](https://github.com/LazyVim/LazyVim/commit/264abdf9d52fe44c1dcb66f0502dcba5a881ea43)) + +## [12.37.0](https://github.com/LazyVim/LazyVim/compare/v12.36.0...v12.37.0) (2024-07-24) + + +### Features + +* **catppuccin:** enable grug-far integration ([#4156](https://github.com/LazyVim/LazyVim/issues/4156)) ([4bf6d85](https://github.com/LazyVim/LazyVim/commit/4bf6d856a805d38c19c8485c7a062d6cbc5cfaa8)) +* **elixir:** add elixirls code actions ([#4148](https://github.com/LazyVim/LazyVim/issues/4148)) ([f94a059](https://github.com/LazyVim/LazyVim/commit/f94a0591b3e5838794b1c3897ec21491aeb080fe)) + + +### Bug Fixes + +* **dap:** don't mess up DAP adapters provided by nvim-dap-python ([#4141](https://github.com/LazyVim/LazyVim/issues/4141)) ([940d7df](https://github.com/LazyVim/LazyVim/commit/940d7df59aac01f6cc587f035d9b4913139fae60)) +* **dap:** extend dap.configurations from .vscode/launch.json ([#4106](https://github.com/LazyVim/LazyVim/issues/4106)) ([caf227d](https://github.com/LazyVim/LazyVim/commit/caf227dd08e83c826800cb88c34c87c600793fa3)) +* **grug-far:** use new transient option ([1c2be20](https://github.com/LazyVim/LazyVim/commit/1c2be200c185a4567c6a634da2b624d9a638fe73)) +* **keymaps:** leader-wd ([f0d8b8b](https://github.com/LazyVim/LazyVim/commit/f0d8b8b293c1fc798b576a74a87f9bd0b59714f3)) +* **keymaps:** leader-wm ([391f506](https://github.com/LazyVim/LazyVim/commit/391f506295607e12db545b85fcbe0e00b1b8efa9)) +* **news:** deprecated API ([f6cd4a3](https://github.com/LazyVim/LazyVim/commit/f6cd4a38c667e3ef56672d723705ecd8a774a0f4)) + +## [12.36.0](https://github.com/LazyVim/LazyVim/compare/v12.35.1...v12.36.0) (2024-07-22) + + +### Features + +* **grug-far:** no longer needed to call visual replace separately ([72d0cad](https://github.com/LazyVim/LazyVim/commit/72d0cad3530d877401ad9674f5266c79fbec396b)) + +## [12.35.1](https://github.com/LazyVim/LazyVim/compare/v12.35.0...v12.35.1) (2024-07-21) + + +### Bug Fixes + +* **grug-far:** only prefill files filter when file has an extension. Closes [#4130](https://github.com/LazyVim/LazyVim/issues/4130) ([6411ab0](https://github.com/LazyVim/LazyVim/commit/6411ab0897f19dad9f902dfee29e101a9a767357)) + +## [12.35.0](https://github.com/LazyVim/LazyVim/compare/v12.34.0...v12.35.0) (2024-07-21) + + +### Features + +* **python:** default to new ruff instead of ruff_lsp ([#4126](https://github.com/LazyVim/LazyVim/issues/4126)) ([61ce1cf](https://github.com/LazyVim/LazyVim/commit/61ce1cfaaf8365e3b5c12b1509064579ab7d80b5)) + +## [12.34.0](https://github.com/LazyVim/LazyVim/compare/v12.33.0...v12.34.0) (2024-07-20) + + +### Features + +* **editor:** replace nvim-spectre with grug-far.nvim ([#4099](https://github.com/LazyVim/LazyVim/issues/4099)) ([0d561a3](https://github.com/LazyVim/LazyVim/commit/0d561a3226b46f6a44c4f2c9be2288f3b52cc351)) +* **indent-blankline:** add which-key toggles ([#4122](https://github.com/LazyVim/LazyVim/issues/4122)) ([a997152](https://github.com/LazyVim/LazyVim/commit/a997152eb2307380888d640440e0732493f82727)) + + +### Bug Fixes + +* **conform:** changes for new conform.nvim config ([eed91a3](https://github.com/LazyVim/LazyVim/commit/eed91a3e4c1521dd839d1a8bc09bdd98ac2fb874)) +* **toggle:** safe toggle get ([c8ab5d7](https://github.com/LazyVim/LazyVim/commit/c8ab5d7554da9f1eff69f5d6d8a0df38309d9f81)) + + +### Performance Improvements + +* **core:** defer clipboard because xsel and pbcopy can be slow ([#4120](https://github.com/LazyVim/LazyVim/issues/4120)) ([578f06e](https://github.com/LazyVim/LazyVim/commit/578f06e1401defbbc0a82f9ff1fb505564d038cf)) + +## [12.33.0](https://github.com/LazyVim/LazyVim/compare/v12.32.0...v12.33.0) (2024-07-19) + + +### Features + +* **extras:** improve ruby extra by letting user chose ([#3652](https://github.com/LazyVim/LazyVim/issues/3652)) ([7839498](https://github.com/LazyVim/LazyVim/commit/783949810855556dd12ed2685e62fb37a4c9504d)) +* **lang:** add Lean 4 support ([#4080](https://github.com/LazyVim/LazyVim/issues/4080)) ([3e29fdf](https://github.com/LazyVim/LazyVim/commit/3e29fdf478383034c48477dd04fd433a7c9327ee)) +* **lang:** add OCaml ([#4079](https://github.com/LazyVim/LazyVim/issues/4079)) ([a219e10](https://github.com/LazyVim/LazyVim/commit/a219e105b0e86316edfedb57f1fa267a764eab13)) + + +### Bug Fixes + +* **ui:** trouble lualine component ([f9fdb35](https://github.com/LazyVim/LazyVim/commit/f9fdb356f2362e5ae4ef490944b1957b49dc6680)) + +## [12.32.0](https://github.com/LazyVim/LazyVim/compare/v12.31.0...v12.32.0) (2024-07-18) + + +### Features + +* **edgy:** added support for grug-far.nvim ([b1a4740](https://github.com/LazyVim/LazyVim/commit/b1a47405b9fa5eb9f5222876e81be73206b80792)) +* **terminal:** clear search highlight when opening a terminal ([#4090](https://github.com/LazyVim/LazyVim/issues/4090)) ([b5290fd](https://github.com/LazyVim/LazyVim/commit/b5290fd92935d2e96fa2249cfd09bdd853972869)) +* **toggle:** move toggle notifs to toggle function ([c1b76ee](https://github.com/LazyVim/LazyVim/commit/c1b76ee235a2cccff6370ecfca57bdacd5fe6258)) + + +### Bug Fixes + +* **autcmds:** desc for close_with_q ([d6561fd](https://github.com/LazyVim/LazyVim/commit/d6561fd27c17806ca972cbfc18573ca81d13e346)) +* **ui:** another typo ([b8bdebe](https://github.com/LazyVim/LazyVim/commit/b8bdebe5be7eba91db23e43575fc1226075f6a56)) +* **ui:** typo ([4ac249b](https://github.com/LazyVim/LazyVim/commit/4ac249beaae3462d606128ca21db79cb85a8c65b)) + +## [12.31.0](https://github.com/LazyVim/LazyVim/compare/v12.30.0...v12.31.0) (2024-07-17) + + +### Features + +* **keymaps:** proxy leader-w to ctrl-w ([bab5440](https://github.com/LazyVim/LazyVim/commit/bab54406dc312947e4e03bb728498503c09231ca)) +* **R:** added new which-key group for new install feature ([#4078](https://github.com/LazyVim/LazyVim/issues/4078)) ([5339aca](https://github.com/LazyVim/LazyVim/commit/5339acacec0996968d64fdbaf9fe8187bfea1b47)) +* **toggle:** make toggles callable. Fixes [#4081](https://github.com/LazyVim/LazyVim/issues/4081) ([150523b](https://github.com/LazyVim/LazyVim/commit/150523b77b6e848c4135a97a5fd8f6f79a6f4443)) +* **treesitter-context:** which-key toggle ([#4059](https://github.com/LazyVim/LazyVim/issues/4059)) ([ab01350](https://github.com/LazyVim/LazyVim/commit/ab0135093bc18ccf82325bc8ee14c25230a71786)) +* **which-key:** dynamic buffer mappings under leader-b ([8d9f2ad](https://github.com/LazyVim/LazyVim/commit/8d9f2ad97ee0d495135380975438ab8a8ae62b14)) +* **which-key:** dynamic window mappings under leader-w ([66bba78](https://github.com/LazyVim/LazyVim/commit/66bba787b83afdd85b5ee95aa589fbe9fbb95535)) +* **which-key:** leader-w-space starts hydra mode for window mappings ([865bf15](https://github.com/LazyVim/LazyVim/commit/865bf15f1cf4d4f6a3eda6d7509f94a59752fb36)) + +## [12.30.0](https://github.com/LazyVim/LazyVim/compare/v12.29.2...v12.30.0) (2024-07-15) + + +### Features + +* **keymaps:** dynamic which-key icons/descriptions for toggles ([#4050](https://github.com/LazyVim/LazyVim/issues/4050)) ([78cf032](https://github.com/LazyVim/LazyVim/commit/78cf0320bfc34050883cde5e7af267184dc60ee9)) +* **util.mini:** follow the user's mappings instead of hardcoded values ([#4043](https://github.com/LazyVim/LazyVim/issues/4043)) ([8506cb5](https://github.com/LazyVim/LazyVim/commit/8506cb5a98a528651a5557d8e447fa13bd8ac0cb)) + + +### Bug Fixes + +* **lsp:** lsp keymaps. Fixes [#4051](https://github.com/LazyVim/LazyVim/issues/4051) ([706ec4b](https://github.com/LazyVim/LazyVim/commit/706ec4b6b6be4265cbcfd326d3216f2a29952b55)) +* **yanky:** enable yank history in visual mode ([#4048](https://github.com/LazyVim/LazyVim/issues/4048)) ([6911327](https://github.com/LazyVim/LazyVim/commit/6911327a5edca85ce3bc71229236494d9af7fafa)) + + +### Performance Improvements + +* **luasnip:** luasnip wasn't lazyloaded ([#4032](https://github.com/LazyVim/LazyVim/issues/4032)) ([e80ed32](https://github.com/LazyVim/LazyVim/commit/e80ed322a79a8b9857c6ab0ad76545654917ddcb)) + +## [12.29.2](https://github.com/LazyVim/LazyVim/compare/v12.29.1...v12.29.2) (2024-07-14) + + +### Bug Fixes + +* **telescope:** better find_command. Fixes [#4031](https://github.com/LazyVim/LazyVim/issues/4031) ([d39cdb0](https://github.com/LazyVim/LazyVim/commit/d39cdb059624b1200f2ef762f30c6e3b74066bc5)) + +## [12.29.1](https://github.com/LazyVim/LazyVim/compare/v12.29.0...v12.29.1) (2024-07-14) + + +### Bug Fixes + +* **omnisharp:** don't detach coreclr debug adapter ([#4023](https://github.com/LazyVim/LazyVim/issues/4023)) ([b3e746b](https://github.com/LazyVim/LazyVim/commit/b3e746b637a0d43aa0195cc1ff3d8adf1fedfaf6)) +* **pick:** get rid of "auto" picker and set better defaults for telescope find_files ([#4024](https://github.com/LazyVim/LazyVim/issues/4024)) ([337e9dd](https://github.com/LazyVim/LazyVim/commit/337e9ddc007d32c624433b5c6f0af6e8697dfcc6)) +* **tailwind:** additional tailwind completion settings for phoenix projects ([#3961](https://github.com/LazyVim/LazyVim/issues/3961)) ([9bce054](https://github.com/LazyVim/LazyVim/commit/9bce054fafcd631ec133a82ada1ecbbd23ca5510)) + +## [12.29.0](https://github.com/LazyVim/LazyVim/compare/v12.28.0...v12.29.0) (2024-07-14) + + +### Features + +* **java:** new java mappings format for which-key v3 ([#4013](https://github.com/LazyVim/LazyVim/issues/4013)) ([28a7f81](https://github.com/LazyVim/LazyVim/commit/28a7f8126c1b46b41ca58845ee081b67ce6981f2)) +* shorter keymap descriptions for mini.ai / yanky ([75ff149](https://github.com/LazyVim/LazyVim/commit/75ff1496bd4209784a4250e59920d24d75a3e3b0)) + + +### Bug Fixes + +* **flit:** use which-key preset keymap descriptions ([#4000](https://github.com/LazyVim/LazyVim/issues/4000)) ([ca37162](https://github.com/LazyVim/LazyVim/commit/ca37162cb7452dce32cf3f0ad661bcd1245286c0)) + +## [12.28.0](https://github.com/LazyVim/LazyVim/compare/v12.27.0...v12.28.0) (2024-07-12) + + +### Features + +* new mappings format for which-key v3. Forgot to push :) ([702471e](https://github.com/LazyVim/LazyVim/commit/702471e454ff552189ab03325dc19d0f7a601704)) + + +### Bug Fixes + +* **autocmds:** fixed pattern for autocommand to autoenable wrap and spell in text files ([#3975](https://github.com/LazyVim/LazyVim/issues/3975)) ([927031a](https://github.com/LazyVim/LazyVim/commit/927031a2de93f694b032a4df5e6d93fff635a496)) +* **java:** fix `config_overrides` for tests ([#3968](https://github.com/LazyVim/LazyVim/issues/3968)) ([b481b64](https://github.com/LazyVim/LazyVim/commit/b481b644ddf9f02470ec50264e63c6dd69d444f8)) +* **outline:** use new object for `symbols.filter` ([#4006](https://github.com/LazyVim/LazyVim/issues/4006)) ([db234ef](https://github.com/LazyVim/LazyVim/commit/db234ef9cbbb1b7b0efa8e3af5c446b965e7c07a)) +* **php:** `php_cs_fixer` is the correct name ([#3991](https://github.com/LazyVim/LazyVim/issues/3991)) ([8bfd9a5](https://github.com/LazyVim/LazyVim/commit/8bfd9a50a71d8b8147f7d742e8d0f05ee6cba888)) +* **vscode:** allow overriding default vscode keymaps. Fixes [#3950](https://github.com/LazyVim/LazyVim/issues/3950) ([6765052](https://github.com/LazyVim/LazyVim/commit/67650528e47a57fb687bce2d7bb61fb4f1af8f63)) + +## [12.27.0](https://github.com/LazyVim/LazyVim/compare/v12.26.2...v12.27.0) (2024-07-07) + + +### Features + +* **icons:** provide language specific icons in extras ([#3931](https://github.com/LazyVim/LazyVim/issues/3931)) ([aa418a2](https://github.com/LazyVim/LazyVim/commit/aa418a2147f52fbe3225aced3a0e7638cf15ea78)) +* **java:** allow overriding test config ([#3891](https://github.com/LazyVim/LazyVim/issues/3891)) ([8b2eacb](https://github.com/LazyVim/LazyVim/commit/8b2eacb6ac2a8df3c9eaba69fbce34abc3666ec1)) + + +### Bug Fixes + +* **fzf-lua:** move register_select to lazy init ([33e1da5](https://github.com/LazyVim/LazyVim/commit/33e1da585d8709bcf6c076e80a73b55ef70a9443)) +* **lazygit:** improve git browse ([#3941](https://github.com/LazyVim/LazyVim/issues/3941)) ([28805d1](https://github.com/LazyVim/LazyVim/commit/28805d1a4c09b8dccbac8db4f7c6576a29abbd40)) + +## [12.26.2](https://github.com/LazyVim/LazyVim/compare/v12.26.1...v12.26.2) (2024-07-07) + + +### Bug Fixes + +* **lualine:** check that trouble is installed ([d108169](https://github.com/LazyVim/LazyVim/commit/d108169e951fff8c65ed8dea89b058717cc48da5)) + +## [12.26.1](https://github.com/LazyVim/LazyVim/compare/v12.26.0...v12.26.1) (2024-07-06) + + +### Bug Fixes + +* **lualine:** use the new ministarter file type to disable in mini.starter ([#3929](https://github.com/LazyVim/LazyVim/issues/3929)) ([330d2e4](https://github.com/LazyVim/LazyVim/commit/330d2e470b79eb31f884685b331d5d255776de90)) +* **mini.starter:** lazyvim startuptime in mini.starter ([#3935](https://github.com/LazyVim/LazyVim/issues/3935)) ([5f952bb](https://github.com/LazyVim/LazyVim/commit/5f952bb9d6927bdc6a4411dc6b1002fa47b3371d)) + +## [12.26.0](https://github.com/LazyVim/LazyVim/compare/v12.25.0...v12.26.0) (2024-07-05) + + +### Features + +* **dial:** yaml support ([f64bbd2](https://github.com/LazyVim/LazyVim/commit/f64bbd29fb279ba672ce1fc9a79b06ecc4237c87)) +* **util:** rest-client ([#3915](https://github.com/LazyVim/LazyVim/issues/3915)) ([76b41cd](https://github.com/LazyVim/LazyVim/commit/76b41cdec421668dd8078e43184674c783554044)) +* **vue:** enabled hybrid mode to avoid 2 typescript lsp running at same time ([#3908](https://github.com/LazyVim/LazyVim/issues/3908)) ([4b0f720](https://github.com/LazyVim/LazyVim/commit/4b0f720457fbbf624406a540b42e9ad7f2e50a77)) + + +### Bug Fixes + +* **dial:** move date related augends to default group ([#3927](https://github.com/LazyVim/LazyVim/issues/3927)) ([4192d95](https://github.com/LazyVim/LazyVim/commit/4192d9578d1946deba76efd1a0ec36e4ba0e1bbf)) +* **outline:** use the correct symbols and filter config format ([#3924](https://github.com/LazyVim/LazyVim/issues/3924)) ([502dac1](https://github.com/LazyVim/LazyVim/commit/502dac1d9aed71aaa9be8c08a4312622742d47f3)) +* **project:** properly close window after changing directory ([#3919](https://github.com/LazyVim/LazyVim/issues/3919)) ([51e99df](https://github.com/LazyVim/LazyVim/commit/51e99dfba104af54947dcb960f277d739db4280c)) + +## [12.25.0](https://github.com/LazyVim/LazyVim/compare/v12.24.0...v12.25.0) (2024-07-04) + + +### Features + +* **erlang:** add Erlang language ([#3911](https://github.com/LazyVim/LazyVim/issues/3911)) ([9c7d3dc](https://github.com/LazyVim/LazyVim/commit/9c7d3dc75e4ecafe8a6dd6ee8fef0bd7711550ac)) +* **fzf-lua:** preview keymaps for git ([#3904](https://github.com/LazyVim/LazyVim/issues/3904)) ([d5f3d39](https://github.com/LazyVim/LazyVim/commit/d5f3d395f490a252125044d0918267eb18298532)) +* **ui:** use `mini.icons` instead of `nvim-wev-devicons` ([#3899](https://github.com/LazyVim/LazyVim/issues/3899)) ([045faec](https://github.com/LazyVim/LazyVim/commit/045faec0351ff9a38fda1af9b06bd7f948e84d28)) + + +### Bug Fixes + +* **fzf:** make sure `vim.ui.select` works when fzf is not loaded yet ([9acadc7](https://github.com/LazyVim/LazyVim/commit/9acadc7ec289966cf8f4f6c37c348f286ed73ffe)) + +## [12.24.0](https://github.com/LazyVim/LazyVim/compare/v12.23.0...v12.24.0) (2024-07-03) + + +### Features + +* **options:** jumpoptions=view ([fe3d0da](https://github.com/LazyVim/LazyVim/commit/fe3d0da5087ecadfee8922fa363d3e84c0ba3461)) + + +### Bug Fixes + +* **dials:** dials.nvim stopped working after making changes to plugin files ([455557c](https://github.com/LazyVim/LazyVim/commit/455557c1f693c6ced946de2322beceb555161417)) + + +### Performance Improvements + +* **fzf:** lazy-load fzf-lua ([b9a8a4a](https://github.com/LazyVim/LazyVim/commit/b9a8a4ad7f39c8ed3f4febb25dabc9ae24110f98)) + +## [12.23.0](https://github.com/LazyVim/LazyVim/compare/v12.22.1...v12.23.0) (2024-07-03) + + +### Features + +* **cmp:** attempt for dynamic width and trimming between fields ([#3873](https://github.com/LazyVim/LazyVim/issues/3873)) ([78cf6ee](https://github.com/LazyVim/LazyVim/commit/78cf6ee024cbf6a17dc8406555eb131994cd8b63)) + + +### Bug Fixes + +* **chezmoi:** missing support for fzf file picker ([#3888](https://github.com/LazyVim/LazyVim/issues/3888)) ([2114a66](https://github.com/LazyVim/LazyVim/commit/2114a6610f6fc6dea2e4937171429252641bd27d)) +* **neo-tree:** remove `branch`, since it obstructs updating to latest version ([#3871](https://github.com/LazyVim/LazyVim/issues/3871)) ([d23731c](https://github.com/LazyVim/LazyVim/commit/d23731c50d149769799d90ae8ec4969a79db3628)) + +## [12.22.1](https://github.com/LazyVim/LazyVim/compare/v12.22.0...v12.22.1) (2024-06-30) + + +### Performance Improvements + +* **markdown:** only run markdownlint-cli2 formatter when there are markdownlint diagnostics for the buffer ([8a6875a](https://github.com/LazyVim/LazyVim/commit/8a6875ab3bc79d5890cf0a65e3ef602c1567fa90)) + + +### Reverts + +* feat(neo-tree): more sane defaults for gitignore and hidden files ([2bfcd05](https://github.com/LazyVim/LazyVim/commit/2bfcd05c621f74b4d735b14b43804a901f17d416)) + +## [12.22.0](https://github.com/LazyVim/LazyVim/compare/v12.21.1...v12.22.0) (2024-06-30) + + +### Features + +* allow a custom path for `lazyvim.json`. Fixes [#3856](https://github.com/LazyVim/LazyVim/issues/3856) ([131187c](https://github.com/LazyVim/LazyVim/commit/131187c092cc42768e0a48a3668e91d009a213a0)) +* **cmp:** disable `item.menu` for Rust filetypes ([#3858](https://github.com/LazyVim/LazyVim/issues/3858)) ([ee44b21](https://github.com/LazyVim/LazyVim/commit/ee44b2189827e6a34530ad8b55f214a0a809c045)) +* **neo-tree:** more sane defaults for gitignore and hidden files ([85405d6](https://github.com/LazyVim/LazyVim/commit/85405d65348cac72343d081a81addfb5c8d43743)) + + +### Bug Fixes + +* **lsp:** prevent setting up mason-lspconfig more than once when setting mslp opts ([8c900f9](https://github.com/LazyVim/LazyVim/commit/8c900f92e735e9c7e9af24b97de740390383a137)) + +## [12.21.1](https://github.com/LazyVim/LazyVim/compare/v12.21.0...v12.21.1) (2024-06-29) + + +### Bug Fixes + +* **git:** use current dir when git not found to get a meaningful error message ([b43ace1](https://github.com/LazyVim/LazyVim/commit/b43ace1ecfbeb87626fbde8973a2717247471b2e)) + + +### Performance Improvements + +* **markdown:** don't format with markdown-toc when no toc in the doc ([73e72ee](https://github.com/LazyVim/LazyVim/commit/73e72ee21d7673e4040bb99f4de834410219d6cb)) + +## [12.21.0](https://github.com/LazyVim/LazyVim/compare/v12.20.1...v12.21.0) (2024-06-29) + + +### Features + +* **extras:** add `overseer.nvim` plugin extra ([#2421](https://github.com/LazyVim/LazyVim/issues/2421)) ([683bf52](https://github.com/LazyVim/LazyVim/commit/683bf52c024306f9c0fccc2b02348692c3f09bfa)) +* **extras:** add chezmoi extra ([#2859](https://github.com/LazyVim/LazyVim/issues/2859)) ([88f2541](https://github.com/LazyVim/LazyVim/commit/88f25410e020fe64fe42a94d71f0be3db1b918b4)) +* **extras:** switch to markdownlint-cli2 ([#3843](https://github.com/LazyVim/LazyVim/issues/3843)) ([f47d105](https://github.com/LazyVim/LazyVim/commit/f47d105b80dce615a572a13351a137653444d548)) +* **java:** enable Lombok support in jdtls ([#3852](https://github.com/LazyVim/LazyVim/issues/3852)) ([0fede40](https://github.com/LazyVim/LazyVim/commit/0fede4040b15da7e74c6a741132ff3d48634c1ad)) + + +### Bug Fixes + +* **bufremove:** fix `Cancel` ([#3834](https://github.com/LazyVim/LazyVim/issues/3834)) ([87fe403](https://github.com/LazyVim/LazyVim/commit/87fe403df62fd8b89b886920c4f562da8e162cbe)) +* **edgy:** improve edgy.lua bufferline offset logic ([#3794](https://github.com/LazyVim/LazyVim/issues/3794)) ([566753b](https://github.com/LazyVim/LazyVim/commit/566753b8889a6132f2e667606a6a002fdd8847b1)) +* **extras:** don't load pkgs when parsing specs for LazyExtras ([3764735](https://github.com/LazyVim/LazyVim/commit/3764735fb20596dfc9cd0707d2830a40004c7f0e)) +* **gitsigns:** fix inconsistent signs ([#3830](https://github.com/LazyVim/LazyVim/issues/3830)) ([44ed11c](https://github.com/LazyVim/LazyVim/commit/44ed11c4f8867cdc887fdcba6a22938125a403ee)) +* **lazygit:** fix browsing private git hostings ([#3833](https://github.com/LazyVim/LazyVim/issues/3833)) ([b292a72](https://github.com/LazyVim/LazyVim/commit/b292a721bfce1b079428a3a42aa9ea3454c5692d)) +* **lint:** make prepend_args opt work when default args is empty ([#3828](https://github.com/LazyVim/LazyVim/issues/3828)) ([ff1b44e](https://github.com/LazyVim/LazyVim/commit/ff1b44e67606080b8b40d066943c55c92856e3c6)) +* **neotest:** support adapter key on adapter for playwright ([#3824](https://github.com/LazyVim/LazyVim/issues/3824)) ([e5e8d7a](https://github.com/LazyVim/LazyVim/commit/e5e8d7a8056a8c80456751385e73a4b184bcd436)) +* **pick:** set recurse_submodules to false when using `auto` picker. Fixes [#3831](https://github.com/LazyVim/LazyVim/issues/3831), Closes [#3835](https://github.com/LazyVim/LazyVim/issues/3835) ([d6429a5](https://github.com/LazyVim/LazyVim/commit/d6429a5c8ad317057cb852d3cd67ce52e9c30727)) + +## [12.20.1](https://github.com/LazyVim/LazyVim/compare/v12.20.0...v12.20.1) (2024-06-26) + + +### Bug Fixes + +* **autocmds:** check that buf exists ([135ce0d](https://github.com/LazyVim/LazyVim/commit/135ce0d7edb64958b2c8f636a9ba624ec0721eb3)) + +## [12.20.0](https://github.com/LazyVim/LazyVim/compare/v12.19.1...v12.20.0) (2024-06-25) + + +### Features + +* **autocmds:** added proper bigfile support ([938a671](https://github.com/LazyVim/LazyVim/commit/938a6718c6f0d5c6716a34bd3383758907820c52)) + + +### Bug Fixes + +* **dashboard:** load dashboard when closing lazy if needed ([fa2fc64](https://github.com/LazyVim/LazyVim/commit/fa2fc6403185faabc47741b3aa2809192870b92e)) +* **elixir:** fix credo detection for elixir linters. ([#3809](https://github.com/LazyVim/LazyVim/issues/3809)) ([c132158](https://github.com/LazyVim/LazyVim/commit/c13215814cd5dc3821625e9f3b55860ba880ebdb)) +* **fzf:** disable `preview` for `vtsls` ([#3798](https://github.com/LazyVim/LazyVim/issues/3798)) ([b5945c2](https://github.com/LazyVim/LazyVim/commit/b5945c2fc8cbb531983c7ec27d283ad8abf1acec)) +* **noice:** dont show old messages when installing plugins ([faee8ce](https://github.com/LazyVim/LazyVim/commit/faee8ce5819c40852f574aafad55701e2492ffae)) +* **util.terminal:** fix the shellredir and shellpipe options for powershell ([#3803](https://github.com/LazyVim/LazyVim/issues/3803)) ([a33eabd](https://github.com/LazyVim/LazyVim/commit/a33eabddd9f3786421652d07894516d946c88647)) + + +### Performance Improvements + +* **markdown:** add filetype in VeryLazy ([3513362](https://github.com/LazyVim/LazyVim/commit/351336244c0a68d4ebed7f687e27e6eab8e5da09)) + +## [12.19.1](https://github.com/LazyVim/LazyVim/compare/v12.19.0...v12.19.1) (2024-06-23) + + +### Bug Fixes + +* **dap:** only load `mason-nvim-dap` when not disabled ([#3784](https://github.com/LazyVim/LazyVim/issues/3784)) ([b55c773](https://github.com/LazyVim/LazyVim/commit/b55c7734df72ff06659c16f5f9ed27b6b7199d44)) +* **extras.astro:** support `astro.config.ts` root ([#3786](https://github.com/LazyVim/LazyVim/issues/3786)) ([8be66bb](https://github.com/LazyVim/LazyVim/commit/8be66bb1a62aae97552032926fdcc101867b2028)) +* **lazygit:** use `lazy.util.open` on Neovim <= 0.10 ([#3778](https://github.com/LazyVim/LazyVim/issues/3778)) ([8ea3f69](https://github.com/LazyVim/LazyVim/commit/8ea3f690e6017ba37022060a62f1d69fbf3aeaf7)) +* **markdown:** added support for mdx files ([abec8fb](https://github.com/LazyVim/LazyVim/commit/abec8fbb03bdbe881c35401274083f315025a1ed)) + +## [12.19.0](https://github.com/LazyVim/LazyVim/compare/v12.18.0...v12.19.0) (2024-06-23) + + +### Features + +* **gitsigns:** navigate diff changes as well as git hunks with [h/]h ([#3736](https://github.com/LazyVim/LazyVim/issues/3736)) ([1f42393](https://github.com/LazyVim/LazyVim/commit/1f423930e03078eb1a2786356a46287c8a466c91)) +* **gitsigns:** new keymap for `Gitsigns blame` ([#3758](https://github.com/LazyVim/LazyVim/issues/3758)) ([b22831b](https://github.com/LazyVim/LazyVim/commit/b22831b7e25a4681df171da30204d4d4f7e9abfa)) +* **go:** switch to neotest-golang ([#3749](https://github.com/LazyVim/LazyVim/issues/3749)) ([55464b7](https://github.com/LazyVim/LazyVim/commit/55464b77c6ae8f14306ce743bcb3c5c465af3d4f)) + + +### Bug Fixes + +* **neo-tree:** don't enable document symbols by default ([52d4616](https://github.com/LazyVim/LazyVim/commit/52d46166b14a9e99509c509482d9a0979fa00809)) +* **refactoring:** use `pick` for both Telescope and fzf-lua ([#3769](https://github.com/LazyVim/LazyVim/issues/3769)) ([b45d4ed](https://github.com/LazyVim/LazyVim/commit/b45d4ed62c613a4c47dd9183cf51985f2b153b21)) +* **statuscolumn:** fix `folds_open = true` ([#3756](https://github.com/LazyVim/LazyVim/issues/3756)) ([b47c65f](https://github.com/LazyVim/LazyVim/commit/b47c65f4087c4d82720ab7439f395aba5d6b5f40)) + +## [12.18.0](https://github.com/LazyVim/LazyVim/compare/v12.17.0...v12.18.0) (2024-06-19) + + +### Features + +* **extra:** add prisma support and config ([#3684](https://github.com/LazyVim/LazyVim/issues/3684)) ([1101c3e](https://github.com/LazyVim/LazyVim/commit/1101c3ed24709feec85371a951ea0feed6bd50fa)) +* **project:** add fzf-lua keymap descriptions ([#3690](https://github.com/LazyVim/LazyVim/issues/3690)) ([07ab681](https://github.com/LazyVim/LazyVim/commit/07ab681b1d6f0223e6b265f3eb6aaafbd12e5c0e)) + + +### Bug Fixes + +* **dap:** get the correct debugpy pkg path on windows ([#3716](https://github.com/LazyVim/LazyVim/issues/3716)) ([06f13da](https://github.com/LazyVim/LazyVim/commit/06f13daf7261377ecfa6b4ac845d742f446df719)) +* **extras.python:** avoid launching extra console with dap on Windows ([#3723](https://github.com/LazyVim/LazyVim/issues/3723)) ([67eece6](https://github.com/LazyVim/LazyVim/commit/67eece6d74f071035ca7b934a753d71d1677dd9b)) +* **root:** also check root_dir. Fixes [#3732](https://github.com/LazyVim/LazyVim/issues/3732) ([d4991d5](https://github.com/LazyVim/LazyVim/commit/d4991d5aac3c4ab5865e65d73fb8957b3d61bdc3)) +* **statuscolumn:** `%r` deprecated in nightly and `%l` handles everything ([#3719](https://github.com/LazyVim/LazyVim/issues/3719)) ([1a295c5](https://github.com/LazyVim/LazyVim/commit/1a295c5ef8cab02c6054067c35ca805a3e4ccf72)) + +## [12.17.0](https://github.com/LazyVim/LazyVim/compare/v12.16.0...v12.17.0) (2024-06-18) + + +### Features + +* **copilot-chat:** ctrl-s now works in both normal and insert mode ([0fcadce](https://github.com/LazyVim/LazyVim/commit/0fcadced89f96f59a9f9cb0c85ee73990df1219f)) +* **php:** allow using intelephense instead of phpactor in php extras ([#3691](https://github.com/LazyVim/LazyVim/issues/3691)) ([ea3b5cc](https://github.com/LazyVim/LazyVim/commit/ea3b5cc2ab4ff7d70163ab66ea7fa0acc0e88566)) +* **treesitter-textobjects:** added ]a and [a to move between parameters ([18c7731](https://github.com/LazyVim/LazyVim/commit/18c7731281f7a9886ae98d9c034661fa85340fb2)) + + +### Bug Fixes + +* **cmp:** visible ([57ef349](https://github.com/LazyVim/LazyVim/commit/57ef349910ec40c7024f3b50a549aabefa1ebbf0)) +* **conform:** `lsp_format` breaking changes ([#3707](https://github.com/LazyVim/LazyVim/issues/3707)) ([a69e626](https://github.com/LazyVim/LazyVim/commit/a69e626d7a3a027df124bae7b2672658a4fb5b0f)) +* **edgy:** only enable edgy neo-tree when needed. Fixes [#3697](https://github.com/LazyVim/LazyVim/issues/3697). Closes [#3703](https://github.com/LazyVim/LazyVim/issues/3703) ([bdca1e9](https://github.com/LazyVim/LazyVim/commit/bdca1e95ff97348501a715bd6aa5977422a27969)) +* **git:** removed debug info ([d9caee6](https://github.com/LazyVim/LazyVim/commit/d9caee610038548a4b79f2b6eb126180ec8ba6b6)) +* **lazygit:** support monorepo structure and other git providers ([#3701](https://github.com/LazyVim/LazyVim/issues/3701)) ([1f034e1](https://github.com/LazyVim/LazyVim/commit/1f034e16000692d1d0ec8e02110d37cf2089bd4c)) +* **lsp:** dont highlight document words when cmp is visible ([0d57115](https://github.com/LazyVim/LazyVim/commit/0d57115f01b4094f68e426942e14892f204ec664)) +* **snippets:** nvim-snippets `<S-Tab>` prev key ([#3712](https://github.com/LazyVim/LazyVim/issues/3712)) ([492fa86](https://github.com/LazyVim/LazyVim/commit/492fa86faa29f2987f662ad0cdb796b5c1c49ef3)) + +## [12.16.0](https://github.com/LazyVim/LazyVim/compare/v12.15.0...v12.16.0) (2024-06-16) + + +### Features + +* **fzf:** basic image viewing support ([cda30f2](https://github.com/LazyVim/LazyVim/commit/cda30f2740f0479098e93a546a741aeefad535cc)) +* **mini.pairs:** allow to skip pairs in certain treesitter nodes ([d6bea06](https://github.com/LazyVim/LazyVim/commit/d6bea06a82912e324ec86438708e619aaa3adce0)) +* **mini.pairs:** and now the actual code :) ([540261d](https://github.com/LazyVim/LazyVim/commit/540261d74d2a743f3bff7eb9749cddeea1d29b19)) +* **mini.pairs:** enable mini.pairs in the cmdline ([2daca4b](https://github.com/LazyVim/LazyVim/commit/2daca4b51014a1a14ce8a5ccdd9fdf08a51db3db)) +* **outline:** free ctrl-k /ctrl+j ([#3686](https://github.com/LazyVim/LazyVim/issues/3686)) ([31c2ad7](https://github.com/LazyVim/LazyVim/commit/31c2ad7dac2e711018b3e1393c5b995515b2ef5e)) +* **project:** add some fzf-lua keymap ([#3666](https://github.com/LazyVim/LazyVim/issues/3666)) ([f24999f](https://github.com/LazyVim/LazyVim/commit/f24999fd3645756a338137278ccc4fa3e1240a90)) + + +### Bug Fixes + +* **edgy:** neo-tree. See [#3667](https://github.com/LazyVim/LazyVim/issues/3667) ([f22a602](https://github.com/LazyVim/LazyVim/commit/f22a6022c4e97bc8dc6060479fe4188e1a953c1e)) +* **egdy:** do not add panes for not enabled neo-tree sources ([#3667](https://github.com/LazyVim/LazyVim/issues/3667)) ([67616b9](https://github.com/LazyVim/LazyVim/commit/67616b9520a5309d2e3565ff880b37ceef662179)) +* **pick:** remove the unused commands attribute ([#3673](https://github.com/LazyVim/LazyVim/issues/3673)) ([eca8692](https://github.com/LazyVim/LazyVim/commit/eca86924510676667a3868efc512588749f6594e)) +* **telescope:** default to follow=true ([b87d18c](https://github.com/LazyVim/LazyVim/commit/b87d18cc17300c49bf8bec4b81a3416024a39a21)) + +## [12.15.0](https://github.com/LazyVim/LazyVim/compare/v12.14.1...v12.15.0) (2024-06-15) + + +### Features + +* **mini.pairs:** added some custom options to make mini.pairs behave better ([bf809ad](https://github.com/LazyVim/LazyVim/commit/bf809ad2a1f6cd8f74451feacdd79af68d201d6e)) +* **project:** ctrl-t opens project in tab ([f28937b](https://github.com/LazyVim/LazyVim/commit/f28937b0c53195a90fb450d0f07bacd3321a0cfd)) + + +### Bug Fixes + +* **dap:** make sure mason-dap is loaded after initializing dap. See [#3663](https://github.com/LazyVim/LazyVim/issues/3663) ([e0e1ab0](https://github.com/LazyVim/LazyVim/commit/e0e1ab01af01f393d4c96f943faddcc62f6eda16)) +* **dap:** make sure mason-nvim-dap loads after nvim-dap ([2b703ac](https://github.com/LazyVim/LazyVim/commit/2b703ac125a21b48bb207d86cddbb461189d025b)) +* **elixir:** add missing lspconfig ([#3661](https://github.com/LazyVim/LazyVim/issues/3661)) ([06f5ef9](https://github.com/LazyVim/LazyVim/commit/06f5ef928f61dbb64ee0555cddf556bc01cc62f4)) +* **fzf:** only add trouble integration when trouble is available ([e1f587a](https://github.com/LazyVim/LazyVim/commit/e1f587a43dce83c652db5c6742cf516d983152a3)) +* **rust:** incorporate latest changes from `rustaceanvim` ([#3655](https://github.com/LazyVim/LazyVim/issues/3655)) ([2d68976](https://github.com/LazyVim/LazyVim/commit/2d689763e43f9c744f4893a6d68fcb8308502053)) +* **vue:** disable volar hybrid mode since it interferes with tsserver ([#3654](https://github.com/LazyVim/LazyVim/issues/3654)) ([5070694](https://github.com/LazyVim/LazyVim/commit/5070694861f91ac258fbf851ed771294cafafb8f)) + +## [12.14.1](https://github.com/LazyVim/LazyVim/compare/v12.14.0...v12.14.1) (2024-06-14) + + +### Bug Fixes + +* **edgy:** only track other neo-tree windows with a source ([6efbdab](https://github.com/LazyVim/LazyVim/commit/6efbdabd1b2272401566354686ce85e1372fe925)) +* **extras:** better reasons as to why some extras are included in your config. ([eeccbbc](https://github.com/LazyVim/LazyVim/commit/eeccbbc40721bb825182251acf201750741c77b2)) +* **fzf:** esc and c-j, c-k keymaps with nowait. update fzf-lua as well ([c9380a3](https://github.com/LazyVim/LazyVim/commit/c9380a309dbdc9fe45ec1bc9f8f27700540c2eea)) +* **fzf:** esc and nowait ([7c7703d](https://github.com/LazyVim/LazyVim/commit/7c7703d79226cda99b1ec3d25fbfff54af04ba5b)) +* **fzf:** floating previewer closed fail ([#3638](https://github.com/LazyVim/LazyVim/issues/3638)) ([427e57d](https://github.com/LazyVim/LazyVim/commit/427e57ddf7030f7081d858d923fb9337f94bf0a7)) +* **issue template:** repro.lua didn't work ([#3628](https://github.com/LazyVim/LazyVim/issues/3628)) ([25cccb5](https://github.com/LazyVim/LazyVim/commit/25cccb5db858ad0640fd6a9eb5da4c5f465749d9)) +* **pick:** allow configuring pickers without LazyExtras. Fixes [#3626](https://github.com/LazyVim/LazyVim/issues/3626) ([304e743](https://github.com/LazyVim/LazyVim/commit/304e7439aa8ae646adafb737b292707bf77a31d9)) + +## [12.14.0](https://github.com/LazyVim/LazyVim/compare/v12.13.0...v12.14.0) (2024-06-13) + + +### Features + +* **fzf:** better default window size/position ([74cf6e4](https://github.com/LazyVim/LazyVim/commit/74cf6e446247661ccb074838f92537c96a378ff4)) +* **fzf:** better layout for code actions ([e948435](https://github.com/LazyVim/LazyVim/commit/e948435f17afbbccfe1e7f2b355977efce9f1ff8)) +* **fzf:** disable dressing in favor of noice (vim.ui.input) and fzf-lua (vim.ui.select) ([5c876b7](https://github.com/LazyVim/LazyVim/commit/5c876b754999eb5fe8b79c5b6f5249b5bbddb454)) +* **fzf:** use vscode style path names formatter ([14d1ca9](https://github.com/LazyVim/LazyVim/commit/14d1ca93d0e927b60fdf43424158f2336437f3a6)) +* **noice:** added support for fzf-lua. Closes [#3596](https://github.com/LazyVim/LazyVim/issues/3596) ([ec3dba2](https://github.com/LazyVim/LazyVim/commit/ec3dba20af86187a44c953eb326725f76559cc12)) +* **pick:** move pickers to extras (telescope still the default) ([#3606](https://github.com/LazyVim/LazyVim/issues/3606)) ([39a908c](https://github.com/LazyVim/LazyVim/commit/39a908c9faca2387c5444de89191275b7bd02576)) +* **yanky:** added fzf-lua support ([82f680e](https://github.com/LazyVim/LazyVim/commit/82f680ee6b681f9f39fbfb8431a4f362af134d1c)) + + +### Bug Fixes + +* **dashboard:** proper fix for dashboard's weird action loading ([1d50c75](https://github.com/LazyVim/LazyVim/commit/1d50c75a4b149f1cf00f4d4163f1469bc2fa77fc)) +* **lsp:** add file completion to rename file ([52b5728](https://github.com/LazyVim/LazyVim/commit/52b572881b6fcbc805e5e584c4970c920d314f86)) +* **pick:** ignore registering the same picker ([48a70aa](https://github.com/LazyVim/LazyVim/commit/48a70aa8f5e201dc6c0a4997f4084193dd9b29a5)) +* **pick:** move some leftovers from `editor.lua` to `editor.telescope` ([#3620](https://github.com/LazyVim/LazyVim/issues/3620)) ([b9f7264](https://github.com/LazyVim/LazyVim/commit/b9f726404fce2f5db8bfec713ed3e053537586ad)) +* **pick:** use LazyVim.pick instead of M since dashboard dumps/loadstrings functions. Why though... Fixes [#3617](https://github.com/LazyVim/LazyVim/issues/3617) ([425e6e0](https://github.com/LazyVim/LazyVim/commit/425e6e0ea3006c87645240d003a3b289cbfc446a)) +* **project:** add fzf-lua integration. Fixes [#3609](https://github.com/LazyVim/LazyVim/issues/3609) ([4b9e4ed](https://github.com/LazyVim/LazyVim/commit/4b9e4edbb115f1f13906b2cdb68986e336b05729)) +* **project:** telescope name ([d82c11f](https://github.com/LazyVim/LazyVim/commit/d82c11f889b03effa5248170ac1b4b4681391f08)) +* **python:** only enable venv-selector when telescope is availble. See [#3612](https://github.com/LazyVim/LazyVim/issues/3612) ([74c1766](https://github.com/LazyVim/LazyVim/commit/74c1766479411357054819b5d8c8376ca12c2504)) +* **ui:** use `LazyVim.pick` for alpha.nvim and mini.starter extras ([#3611](https://github.com/LazyVim/LazyVim/issues/3611)) ([339979d](https://github.com/LazyVim/LazyVim/commit/339979d3143d46a37c304d45a00c7a4f448e707d)) + +## [12.13.0](https://github.com/LazyVim/LazyVim/compare/v12.12.0...v12.13.0) (2024-06-11) + + +### Features + +* **copilot-chat:** use fzf-lua if enabled in extras ([#3590](https://github.com/LazyVim/LazyVim/issues/3590)) ([7252474](https://github.com/LazyVim/LazyVim/commit/7252474624cda30cac399b7f419ad25665e62a8f)) +* **fzf:** added ctrl-u and ctrl+d to scroll in the results list ([9f2a369](https://github.com/LazyVim/LazyVim/commit/9f2a3699a8f47467359f2c3defb3a711b32e0efb)) +* **fzf:** added ctrl-x to jump with easymotion to a line, similar to flash telescope ([1c740ce](https://github.com/LazyVim/LazyVim/commit/1c740ce3fdb5e361ec20e5e8cca5a6a79b24ed44)) +* **fzf:** use delta previewer for code actions when available ([1697100](https://github.com/LazyVim/LazyVim/commit/16971006c250f11d5ee3cfc974da0c34ab159286)) + + +### Bug Fixes + +* **fzf:** action desc ([c6ddb23](https://github.com/LazyVim/LazyVim/commit/c6ddb2328d596771ee562f49462ae10dfc49321f)) +* **fzf:** added action descriptions. (still doesnt work for trouble) ([19a6e2d](https://github.com/LazyVim/LazyVim/commit/19a6e2de158e63264aaa761228a1e3f9d615bd57)) +* **fzf:** cleanup ([79b7c48](https://github.com/LazyVim/LazyVim/commit/79b7c489fdacd0a04e7025e72e9020c4ff595eb3)) +* **fzf:** disable mini.indentscope in fzf-lua buffer ([#3592](https://github.com/LazyVim/LazyVim/issues/3592)) ([0ba67c8](https://github.com/LazyVim/LazyVim/commit/0ba67c87e9054e09d562164de7ed1876587a0539)) +* **fzf:** live document symbols. Fixes [#3587](https://github.com/LazyVim/LazyVim/issues/3587) ([056042b](https://github.com/LazyVim/LazyVim/commit/056042b221c93a14c6069d4a82b7435fc9a228fd)) +* **fzf:** symbols filter ([7e0ac68](https://github.com/LazyVim/LazyVim/commit/7e0ac6850b613ba8cbc179fa2f71199184504a54)) +* **vue:** disable inlay hints for vue, since they seem broken ([3233385](https://github.com/LazyVim/LazyVim/commit/3233385ddb61d01f87de374c061696a374596a10)) + + +### Reverts + +* "fix(dap): set host to 127.0.0.1 instead of localhost to prevent issues with ipv6. Fixes [#3577](https://github.com/LazyVim/LazyVim/issues/3577)" ([a3547e4](https://github.com/LazyVim/LazyVim/commit/a3547e4b3b03e019dbe7e543104ffd1ea82fa765)) + +## [12.12.0](https://github.com/LazyVim/LazyVim/compare/v12.11.0...v12.12.0) (2024-06-11) + + +### Features + +* **extras:** added fzf-lua ([#3555](https://github.com/LazyVim/LazyVim/issues/3555)) ([6ab4041](https://github.com/LazyVim/LazyVim/commit/6ab404134db6004aab13dcf956e200ff063b2d42)) +* **fzf:** better scrollbars ([8bb6538](https://github.com/LazyVim/LazyVim/commit/8bb653876c38518e4befb496b78659e76ed7afee)) +* **fzf:** ignore current line for some lsp pickers ([c481861](https://github.com/LazyVim/LazyVim/commit/c4818616d541e4456850d1982be39b8151bd0f2a)) +* **fzf:** prettier document symbols ([ba3aec7](https://github.com/LazyVim/LazyVim/commit/ba3aec7b4876e36a9f9fd3cce1d204c23c0fe24f)) +* **lualine:** show readonly icon ([#3567](https://github.com/LazyVim/LazyVim/issues/3567)) ([21617a9](https://github.com/LazyVim/LazyVim/commit/21617a9d602f2400c8e9813490958e106cb88ca8)) + + +### Bug Fixes + +* **dap:** set host to 127.0.0.1 instead of localhost to prevent issues with ipv6. Fixes [#3577](https://github.com/LazyVim/LazyVim/issues/3577) ([9b8a393](https://github.com/LazyVim/LazyVim/commit/9b8a393edc8b9a12a39f712163f6476c084a7f71)) +* **extras.copilot-chat:** small ui fix for which-key in visual mode ([#3573](https://github.com/LazyVim/LazyVim/issues/3573)) ([43afed1](https://github.com/LazyVim/LazyVim/commit/43afed121195df6591d0e941b913b98f849c8af3)) +* **fzf:** lowercase symbols ([d1d24fa](https://github.com/LazyVim/LazyVim/commit/d1d24fa077add680bc532e08fd68aaa0841a14dc)) +* **neo-tree:** use last window for preview ([#3560](https://github.com/LazyVim/LazyVim/issues/3560)) ([caaa6c4](https://github.com/LazyVim/LazyVim/commit/caaa6c440d5c3b80c03cad1dfd93989b852bb875)) +* **php:** formatting and linting ([#3540](https://github.com/LazyVim/LazyVim/issues/3540)) ([f5dc867](https://github.com/LazyVim/LazyVim/commit/f5dc867ac29e31f833442006ebe3daf7540d1f69)) +* **pick:** recent files in cwd. Fixes [#3580](https://github.com/LazyVim/LazyVim/issues/3580) ([d541069](https://github.com/LazyVim/LazyVim/commit/d541069fdffcf5ffaf2a7f161fd87bb68094c8cf)) +* **sql:** make sure edgebars exist. Fixes [#3578](https://github.com/LazyVim/LazyVim/issues/3578) ([bd29f45](https://github.com/LazyVim/LazyVim/commit/bd29f4515307f59437995d5cc0ba601eb02b5baa)) +* **util:** ensure unique cache keys in LazyVim.memoize ([#3576](https://github.com/LazyVim/LazyVim/issues/3576)) ([3354872](https://github.com/LazyVim/LazyVim/commit/335487282a128d6df7ea021a75b31f07a2b9ccfd)) + ## [12.11.0](https://github.com/LazyVim/LazyVim/compare/v12.10.0...v12.11.0) (2024-06-09) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 16198586..d08a3622 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -17,6 +17,9 @@ ## Contributing an Extra Language +- You should be familiar with the language you are adding. +- You should have experience with the language's ecosystem, including formatters, + linters, and LSP servers. - The extra should include the setup most widely used by the community. - Include Tree-sitter parsers that are not yet the default. - Include the most widely used LSP server setup. diff --git a/NEWS.md b/NEWS.md index 3abd43b7..20b6156b 100644 --- a/NEWS.md +++ b/NEWS.md @@ -2,6 +2,12 @@ ## 12.x +- **Markdown Extra**: [headlines.nvim](https://github.com/lukas-reineke/headlines.nvim) has been removed in favor of [markdown.nvim](https://github.com/MeanderingProgrammer/markdown.nvim) + to spice up your markdown files. + +- [nvim-spectre](https://github.com/nvim-pack/nvim-spectre) has been removed in favor of [grug-far.nvim](https://github.com/MagicDuck/grug-far.nvim). + **grug-far.nvim** has a great UI and feels more intuitive to use. + - This **news** is now also available on the website at [https://www.lazyvim.org/news](https://www.lazyvim.org/news) - **prettier** extra now works for all prettier supported filetypes diff --git a/README-CN.md b/README-CN.md index 395e146e..b78a398a 100644 --- a/README-CN.md +++ b/README-CN.md @@ -113,6 +113,10 @@ docker run -w /root -it --rm alpine:edge sh -uelic ' [![Watch the video](https://img.youtube.com/vi/N93cTbtLCIM/hqdefault.jpg)](https://www.youtube.com/watch?v=N93cTbtLCIM) +[@dusty-phillips](https://github.com/dusty-phillips) 正在编写一本名为 +[LazyVim for Ambitious Developers](https://lazyvim-ambitious-devs.phillips.codes) +的书，该书可在线免费获得。 + ## 📂 文件结构 config 下的文件会在适当的时候自动加载，所以你不需要手动引入这些文件。 diff --git a/doc/LazyVim.txt b/doc/LazyVim.txt index 3741c67c..70d3657a 100644 --- a/doc/LazyVim.txt +++ b/doc/LazyVim.txt @@ -1,4 +1,4 @@ -*LazyVim.txt* For Neovim >= 0.9.0 Last change: 2024 June 10 +*LazyVim.txt* For Neovim Last change: 2024 July 25 ============================================================================== Table of Contents *LazyVim-table-of-contents* diff --git a/lua/lazyvim/config/autocmds.lua b/lua/lazyvim/config/autocmds.lua index 2fc283ba..edb392db 100644 --- a/lua/lazyvim/config/autocmds.lua +++ b/lua/lazyvim/config/autocmds.lua @@ -55,6 +55,7 @@ vim.api.nvim_create_autocmd("FileType", { group = augroup("close_with_q"), pattern = { "PlenaryTestPopup", + "grug-far", "help", "lspinfo", "notify", @@ -67,10 +68,15 @@ vim.api.nvim_create_autocmd("FileType", { "neotest-summary", "neotest-output-panel", "dbout", + "gitsigns.blame", }, callback = function(event) vim.bo[event.buf].buflisted = false - vim.keymap.set("n", "q", "close", { buffer = event.buf, silent = true }) + vim.keymap.set("n", "q", "close", { + buffer = event.buf, + silent = true, + desc = "Quit buffer", + }) end, }) @@ -86,7 +92,7 @@ vim.api.nvim_create_autocmd("FileType", { -- wrap and check for spell in text filetypes vim.api.nvim_create_autocmd("FileType", { group = augroup("wrap_spell"), - pattern = { "*.txt", "*.tex", "*.typ", "gitcommit", "markdown" }, + pattern = { "text", "plaintex", "typst", "gitcommit", "markdown" }, callback = function() vim.opt_local.wrap = true vim.opt_local.spell = true @@ -113,3 +119,29 @@ vim.api.nvim_create_autocmd({ "BufWritePre" }, { vim.fn.mkdir(vim.fn.fnamemodify(file, ":p:h"), "p") end, }) + +vim.filetype.add({ + pattern = { + [".*"] = { + function(path, buf) + return vim.bo[buf] + and vim.bo[buf].filetype ~= "bigfile" + and path + and vim.fn.getfsize(path) > vim.g.bigfile_size + and "bigfile" + or nil + end, + }, + }, +}) + +vim.api.nvim_create_autocmd({ "FileType" }, { + group = augroup("bigfile"), + pattern = "bigfile", + callback = function(ev) + vim.b.minianimate_disable = true + vim.schedule(function() + vim.bo[ev.buf].syntax = vim.filetype.match({ buf = ev.buf }) or "" + end) + end, +}) diff --git a/lua/lazyvim/config/init.lua b/lua/lazyvim/config/init.lua index de41ec8c..f6978842 100644 --- a/lua/lazyvim/config/init.lua +++ b/lua/lazyvim/config/init.lua @@ -3,7 +3,7 @@ _G.LazyVim = require("lazyvim.util") ---@class LazyVimConfig: LazyVimOptions local M = {} -M.version = "10.21.1" -- x-release-please-version +M.version = "12.38.2" -- x-release-please-version LazyVim.config = M ---@class LazyVimOptions @@ -136,6 +136,7 @@ local defaults = { M.json = { version = 6, + path = vim.g.lazyvim_json or vim.fn.stdpath("config") .. "/lazyvim.json", data = { version = nil, ---@type string? news = {}, ---@type table @@ -144,8 +145,7 @@ M.json = { } function M.json.load() - local path = vim.fn.stdpath("config") .. "/lazyvim.json" - local f = io.open(path, "r") + local f = io.open(M.json.path, "r") if f then local data = f:read("*a") f:close() @@ -161,6 +161,7 @@ end ---@type LazyVimOptions local options +local lazy_clipboard ---@param opts? LazyVimOptions function M.setup(opts) @@ -181,6 +182,9 @@ function M.setup(opts) M.load("autocmds") end M.load("keymaps") + if lazy_clipboard ~= nil then + vim.opt.clipboard = lazy_clipboard + end LazyVim.format.setup() LazyVim.news.setup() @@ -248,16 +252,17 @@ function M.load(name) end, { msg = "Failed loading " .. mod }) end end + local pattern = "LazyVim" .. name:sub(1, 1):upper() .. name:sub(2) -- always load lazyvim, then user file if M.defaults[name] or name == "options" then _load("lazyvim.config." .. name) + vim.api.nvim_exec_autocmds("User", { pattern = pattern .. "Defaults", modeline = false }) end _load("config." .. name) if vim.bo.filetype == "lazy" then -- HACK: LazyVim may have overwritten options of the Lazy ui, so reset this here vim.cmd([[do VimResized]]) end - local pattern = "LazyVim" .. name:sub(1, 1):upper() .. name:sub(2) vim.api.nvim_exec_autocmds("User", { pattern = pattern, modeline = false }) end @@ -284,6 +289,9 @@ function M.init() -- this is needed to make sure options will be correctly applied -- after installing missing plugins M.load("options") + -- defer built-in clipboard handling: "xsel" and "pbcopy" can be slow + lazy_clipboard = vim.opt.clipboard + vim.opt.clipboard = "" if vim.g.deprecation_warnings == false then vim.deprecate = function() end diff --git a/lua/lazyvim/config/keymaps.lua b/lua/lazyvim/config/keymaps.lua index 48ae24f8..a6f1c574 100644 --- a/lua/lazyvim/config/keymaps.lua +++ b/lua/lazyvim/config/keymaps.lua @@ -115,20 +115,19 @@ map("n", "[w", diagnostic_goto(false, "WARN"), { desc = "Prev Warning" }) -- stylua: ignore start -- toggle options -map("n", "uf", function() LazyVim.format.toggle() end, { desc = "Toggle Auto Format (Global)" }) -map("n", "uF", function() LazyVim.format.toggle(true) end, { desc = "Toggle Auto Format (Buffer)" }) -map("n", "us", function() LazyVim.toggle("spell") end, { desc = "Toggle Spelling" }) -map("n", "uw", function() LazyVim.toggle("wrap") end, { desc = "Toggle Word Wrap" }) -map("n", "uL", function() LazyVim.toggle("relativenumber") end, { desc = "Toggle Relative Line Numbers" }) -map("n", "ul", function() LazyVim.toggle.number() end, { desc = "Toggle Line Numbers" }) -map("n", "ud", function() LazyVim.toggle.diagnostics() end, { desc = "Toggle Diagnostics" }) -local conceallevel = vim.o.conceallevel > 0 and vim.o.conceallevel or 3 -map("n", "uc", function() LazyVim.toggle("conceallevel", false, {0, conceallevel}) end, { desc = "Toggle Conceal" }) -if vim.lsp.buf.inlay_hint or vim.lsp.inlay_hint then - map( "n", "uh", function() LazyVim.toggle.inlay_hints() end, { desc = "Toggle Inlay Hints" }) +LazyVim.toggle.map("uf", LazyVim.toggle.format()) +LazyVim.toggle.map("uF", LazyVim.toggle.format(true)) +LazyVim.toggle.map("us", LazyVim.toggle("spell", { name = "Spelling" })) +LazyVim.toggle.map("uw", LazyVim.toggle("wrap", { name = "Wrap" })) +LazyVim.toggle.map("uL", LazyVim.toggle("relativenumber", { name = "Relative Number" })) +LazyVim.toggle.map("ud", LazyVim.toggle.diagnostics) +LazyVim.toggle.map("ul", LazyVim.toggle.number) +LazyVim.toggle.map( "uc", LazyVim.toggle("conceallevel", { values = { 0, vim.o.conceallevel > 0 and vim.o.conceallevel or 2 } })) +LazyVim.toggle.map("uT", LazyVim.toggle.treesitter) +LazyVim.toggle.map("ub", LazyVim.toggle("background", { values = { "light", "dark" }, name = "Background" })) +if vim.lsp.inlay_hint then + LazyVim.toggle.map("uh", LazyVim.toggle.inlay_hints) end -map("n", "uT", function() if vim.b.ts_highlight then vim.treesitter.stop() else vim.treesitter.start() end end, { desc = "Toggle Treesitter Highlight" }) -map("n", "ub", function() LazyVim.toggle("background", false, {"light", "dark"}) end, { desc = "Toggle Background" }) -- lazygit map("n", "gg", function() LazyVim.lazygit( { cwd = LazyVim.root.git() }) end, { desc = "Lazygit (Root Dir)" }) @@ -175,13 +174,11 @@ map("t", "", "close", { desc = "Hide Terminal" }) map("t", "", "close", { desc = "which_key_ignore" }) -- windows -map("n", "ww", "p", { desc = "Other Window", remap = true }) -map("n", "wd", "c", { desc = "Delete Window", remap = true }) -map("n", "w-", "s", { desc = "Split Window Below", remap = true }) -map("n", "w|", "v", { desc = "Split Window Right", remap = true }) +map("n", "w", "", { desc = "Windows", remap = true }) map("n", "-", "s", { desc = "Split Window Below", remap = true }) map("n", "|", "v", { desc = "Split Window Right", remap = true }) -map("n", "wm", function() LazyVim.toggle.maximize() end, { desc = "Maximize Toggle" }) +map("n", "wd", "c", { desc = "Delete Window", remap = true }) +LazyVim.toggle.map("wm", LazyVim.toggle.maximize) -- tabs map("n", "l", "tablast", { desc = "Last Tab" }) diff --git a/lua/lazyvim/config/options.lua b/lua/lazyvim/config/options.lua index b82a763a..a8d512fc 100644 --- a/lua/lazyvim/config/options.lua +++ b/lua/lazyvim/config/options.lua @@ -5,6 +5,12 @@ vim.g.maplocalleader = "\\" -- LazyVim auto format vim.g.autoformat = true +-- LazyVim picker to use. +-- Can be one of: telescope, fzf +-- Leave it to "auto" to automatically use the picker +-- enabled with `:LazyExtras` +vim.g.lazyvim_picker = "auto" + -- LazyVim root dir detection -- Each entry can be: -- * the name of a detector function like `lsp` or `cwd` @@ -34,7 +40,14 @@ vim.g.lazyvim_statuscolumn = { -- Hide deprecation warnings vim.g.deprecation_warnings = false +-- Set filetype to `bigfile` for files larger than 1.5 MB +-- Only vim syntax will be enabled (with the correct filetype) +-- LSP, treesitter and other ft plugins will be disabled. +-- mini.animate will also be disabled. +vim.g.bigfile_size = 1024 * 1024 * 1.5 -- 1.5 MB + -- Show the current document symbols location from Trouble in lualine +-- You can disable this for a buffer by setting `vim.b.trouble_lualine = false` vim.g.trouble_lualine = true local opt = vim.opt @@ -63,6 +76,7 @@ opt.grepformat = "%f:%l:%c:%m" opt.grepprg = "rg --vimgrep" opt.ignorecase = true -- Ignore case opt.inccommand = "nosplit" -- preview incremental substitute +opt.jumpoptions = "view" opt.laststatus = 3 -- global statusline opt.linebreak = true -- Wrap lines at convenient points opt.list = true -- Show some invisible characters (tabs... diff --git a/lua/lazyvim/plugins/coding.lua b/lua/lazyvim/plugins/coding.lua index 155cfe80..8b982033 100644 --- a/lua/lazyvim/plugins/coding.lua +++ b/lua/lazyvim/plugins/coding.lua @@ -23,19 +23,19 @@ return { vim.api.nvim_set_hl(0, "CmpGhostText", { link = "Comment", default = true }) local cmp = require("cmp") local defaults = require("cmp.config.default")() + local auto_select = true return { auto_brackets = {}, -- configure any filetype to auto add brackets completion = { - completeopt = "menu,menuone,noinsert", + completeopt = "menu,menuone,noinsert" .. (auto_select and "" or ",noselect"), }, + preselect = auto_select and cmp.PreselectMode.Item or cmp.PreselectMode.None, mapping = cmp.mapping.preset.insert({ - [""] = cmp.mapping.select_next_item({ behavior = cmp.SelectBehavior.Insert }), - [""] = cmp.mapping.select_prev_item({ behavior = cmp.SelectBehavior.Insert }), [""] = cmp.mapping.scroll_docs(-4), [""] = cmp.mapping.scroll_docs(4), [""] = cmp.mapping.complete(), - [""] = cmp.mapping.abort(), - [""] = LazyVim.cmp.confirm(), + [""] = LazyVim.cmp.confirm({ select = auto_select }), + [""] = LazyVim.cmp.confirm({ select = true }), [""] = LazyVim.cmp.confirm({ behavior = cmp.ConfirmBehavior.Replace }), -- Accept currently selected item. Set `select` to `false` to only confirm explicitly selected items. [""] = function(fallback) cmp.abort() @@ -49,11 +49,23 @@ return { { name = "buffer" }, }), formatting = { - format = function(_, item) - local icons = require("lazyvim.config").icons.kinds + format = function(entry, item) + local icons = LazyVim.config.icons.kinds if icons[item.kind] then item.kind = icons[item.kind] .. item.kind end + + local widths = { + abbr = vim.g.cmp_widths and vim.g.cmp_widths.abbr or 40, + menu = vim.g.cmp_widths and vim.g.cmp_widths.menu or 30, + } + + for key, width in pairs(widths) do + if item[key] and vim.fn.strdisplaywidth(item[key]) > width then + item[key] = vim.fn.strcharpart(item[key], 0, width - 1) .. "…" + end + end + return item end, }, @@ -65,32 +77,7 @@ return { sorting = defaults.sorting, } end, - ---@param opts cmp.ConfigSchema | {auto_brackets?: string[]} - config = function(_, opts) - for _, source in ipairs(opts.sources) do - source.group_index = source.group_index or 1 - end - - local parse = require("cmp.utils.snippet").parse - require("cmp.utils.snippet").parse = function(input) - local ok, ret = pcall(parse, input) - if ok then - return ret - end - return LazyVim.cmp.snippet_preview(input) - end - - local cmp = require("cmp") - cmp.setup(opts) - cmp.event:on("confirm_done", function(event) - if vim.tbl_contains(opts.auto_brackets or {}, vim.bo.filetype) then - LazyVim.cmp.auto_brackets(event.entry) - end - end) - cmp.event:on("menu_opened", function(event) - LazyVim.cmp.add_missing_snippet_docs(event.window) - end) - end, + main = "lazyvim.util.cmp", }, -- snippets @@ -128,7 +115,7 @@ return { { "", function() - return vim.snippet.active({ direction = -1 }) and "lua vim.snippet.jump(-1)" or "" + return vim.snippet.active({ direction = -1 }) and "lua vim.snippet.jump(-1)" or "" end, expr = true, silent = true, @@ -142,24 +129,20 @@ return { "echasnovski/mini.pairs", event = "VeryLazy", opts = { - mappings = { - ["`"] = { action = "closeopen", pair = "``", neigh_pattern = "[^\\`].", register = { cr = false } }, - }, - }, - keys = { - { - "up", - function() - vim.g.minipairs_disable = not vim.g.minipairs_disable - if vim.g.minipairs_disable then - LazyVim.warn("Disabled auto pairs", { title = "Option" }) - else - LazyVim.info("Enabled auto pairs", { title = "Option" }) - end - end, - desc = "Toggle Auto Pairs", - }, + modes = { insert = true, command = true, terminal = false }, + -- skip autopair when next character is one of these + skip_next = [=[[%w%%%'%[%"%.%`%$]]=], + -- skip autopair when the cursor is inside these treesitter nodes + skip_ts = { "string" }, + -- skip autopair when next character is closing pair + -- and there are more closing pairs than opening pairs + skip_unbalanced = true, + -- better deal with markdown code blocks + markdown = true, }, + config = function(_, opts) + LazyVim.mini.pairs(opts) + end, }, -- comments @@ -174,9 +157,6 @@ return { "echasnovski/mini.ai", event = "VeryLazy", opts = function() - LazyVim.on_load("which-key.nvim", function() - vim.schedule(LazyVim.mini.ai_whichkey) - end) local ai = require("mini.ai") return { n_lines = 500, @@ -200,6 +180,14 @@ return { }, } end, + config = function(_, opts) + require("mini.ai").setup(opts) + LazyVim.on_load("which-key.nvim", function() + vim.schedule(function() + LazyVim.mini.ai_whichkey(opts) + end) + end) + end, }, { diff --git a/lua/lazyvim/plugins/colorscheme.lua b/lua/lazyvim/plugins/colorscheme.lua index bb63326e..c6376e1b 100644 --- a/lua/lazyvim/plugins/colorscheme.lua +++ b/lua/lazyvim/plugins/colorscheme.lua @@ -19,6 +19,7 @@ return { cmp = true, dashboard = true, flash = true, + grug_far = true, gitsigns = true, headlines = true, illuminate = true, diff --git a/lua/lazyvim/plugins/compat/nvim-0_9.lua b/lua/lazyvim/plugins/compat/nvim-0_9.lua index 6488952b..4f971b6f 100644 --- a/lua/lazyvim/plugins/compat/nvim-0_9.lua +++ b/lua/lazyvim/plugins/compat/nvim-0_9.lua @@ -26,4 +26,13 @@ return { "neovim/nvim-lspconfig", dependencies = {}, }, + + -- dummy import to save core imports + { + import = "foobar", + enabled = function() + LazyVim.plugin.save_core() + return false + end, + }, } diff --git a/lua/lazyvim/plugins/editor.lua b/lua/lazyvim/plugins/editor.lua index 8f4891b7..18ded3ae 100644 --- a/lua/lazyvim/plugins/editor.lua +++ b/lua/lazyvim/plugins/editor.lua @@ -1,12 +1,8 @@ -local have_make = vim.fn.executable("make") == 1 -local have_cmake = vim.fn.executable("cmake") == 1 - return { -- file explorer { "nvim-neo-tree/neo-tree.nvim", - branch = "v3.x", cmd = "Neotree", keys = { { @@ -63,7 +59,7 @@ return { }) end, opts = { - sources = { "filesystem", "buffers", "git_status", "document_symbols" }, + sources = { "filesystem", "buffers", "git_status" }, open_files_do_not_replace_types = { "terminal", "Trouble", "trouble", "qf", "Outline" }, filesystem = { bind_to_cwd = false, @@ -89,6 +85,7 @@ return { end, desc = "Open with System Application", }, + ["P"] = { "toggle_preview", config = { use_float = false } }, }, }, default_component_configs = { @@ -131,164 +128,26 @@ return { -- search/replace in multiple files { - "nvim-pack/nvim-spectre", - build = false, - cmd = "Spectre", - opts = { open_cmd = "noswapfile vnew" }, - -- stylua: ignore - keys = { - { "sr", function() require("spectre").open() end, desc = "Replace in Files (Spectre)" }, - }, - }, - - -- Fuzzy finder. - -- The default key bindings to find files will use Telescope's - -- `find_files` or `git_files` depending on whether the - -- directory is a git repo. - { - "nvim-telescope/telescope.nvim", - cmd = "Telescope", - version = false, -- telescope did only one release, so use HEAD for now - dependencies = { - { - "nvim-telescope/telescope-fzf-native.nvim", - build = have_make and "make" - or "cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release && cmake --build build --config Release && cmake --install build --prefix build", - enabled = have_make or have_cmake, - config = function(plugin) - LazyVim.on_load("telescope.nvim", function() - local ok, err = pcall(require("telescope").load_extension, "fzf") - if not ok then - local lib = plugin.dir .. "/build/libfzf." .. (LazyVim.is_win() and "dll" or "so") - if not vim.uv.fs_stat(lib) then - LazyVim.warn("`telescope-fzf-native.nvim` not built. Rebuilding...") - require("lazy").build({ plugins = { plugin }, show = false }):wait(function() - LazyVim.info("Rebuilding `telescope-fzf-native.nvim` done.\nPlease restart Neovim.") - end) - else - LazyVim.error("Failed to load `telescope-fzf-native.nvim`:\n" .. err) - end - end - end) - end, - }, - }, + "MagicDuck/grug-far.nvim", + opts = { headerMaxWidth = 80 }, + cmd = "GrugFar", keys = { { - ",", - "Telescope buffers sort_mru=true sort_lastused=true", - desc = "Switch Buffer", - }, - { "/", LazyVim.telescope("live_grep"), desc = "Grep (Root Dir)" }, - { ":", "Telescope command_history", desc = "Command History" }, - { "", LazyVim.telescope("files"), desc = "Find Files (Root Dir)" }, - -- find - { "fb", "Telescope buffers sort_mru=true sort_lastused=true", desc = "Buffers" }, - { "fc", LazyVim.telescope.config_files(), desc = "Find Config File" }, - { "ff", LazyVim.telescope("files"), desc = "Find Files (Root Dir)" }, - { "fF", LazyVim.telescope("files", { cwd = false }), desc = "Find Files (cwd)" }, - { "fg", "Telescope git_files", desc = "Find Files (git-files)" }, - { "fr", "Telescope oldfiles", desc = "Recent" }, - { "fR", LazyVim.telescope("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" }, - -- git - { "gc", "Telescope git_commits", desc = "Commits" }, - { "gs", "Telescope git_status", desc = "Status" }, - -- search - { 's"', "Telescope registers", desc = "Registers" }, - { "sa", "Telescope autocommands", desc = "Auto Commands" }, - { "sb", "Telescope current_buffer_fuzzy_find", desc = "Buffer" }, - { "sc", "Telescope command_history", desc = "Command History" }, - { "sC", "Telescope commands", desc = "Commands" }, - { "sd", "Telescope diagnostics bufnr=0", desc = "Document Diagnostics" }, - { "sD", "Telescope diagnostics", desc = "Workspace Diagnostics" }, - { "sg", LazyVim.telescope("live_grep"), desc = "Grep (Root Dir)" }, - { "sG", LazyVim.telescope("live_grep", { cwd = false }), desc = "Grep (cwd)" }, - { "sh", "Telescope help_tags", desc = "Help Pages" }, - { "sH", "Telescope highlights", desc = "Search Highlight Groups" }, - { "sj", "Telescope jumplist", desc = "Jumplist" }, - { "sk", "Telescope keymaps", desc = "Key Maps" }, - { "sl", "Telescope loclist", desc = "Location List" }, - { "sM", "Telescope man_pages", desc = "Man Pages" }, - { "sm", "Telescope marks", desc = "Jump to Mark" }, - { "so", "Telescope vim_options", desc = "Options" }, - { "sR", "Telescope resume", desc = "Resume" }, - { "sq", "Telescope quickfix", desc = "Quickfix List" }, - { "sw", LazyVim.telescope("grep_string", { word_match = "-w" }), desc = "Word (Root Dir)" }, - { "sW", LazyVim.telescope("grep_string", { cwd = false, word_match = "-w" }), desc = "Word (cwd)" }, - { "sw", LazyVim.telescope("grep_string"), mode = "v", desc = "Selection (Root Dir)" }, - { "sW", LazyVim.telescope("grep_string", { cwd = false }), mode = "v", desc = "Selection (cwd)" }, - { "uC", LazyVim.telescope("colorscheme", { enable_preview = true }), desc = "Colorscheme with Preview" }, - { - "ss", + "sr", function() - require("telescope.builtin").lsp_document_symbols({ - symbols = require("lazyvim.config").get_kind_filter(), + local grug = require("grug-far") + local ext = vim.bo.buftype == "" and vim.fn.expand("%:e") + grug.grug_far({ + transient = true, + prefills = { + filesFilter = ext and ext ~= "" and "*." .. ext or nil, + }, }) end, - desc = "Goto Symbol", - }, - { - "sS", - function() - require("telescope.builtin").lsp_dynamic_workspace_symbols({ - symbols = require("lazyvim.config").get_kind_filter(), - }) - end, - desc = "Goto Symbol (Workspace)", + mode = { "n", "v" }, + desc = "Search and Replace", }, }, - opts = function() - local actions = require("telescope.actions") - - local open_with_trouble = function(...) - return require("trouble.sources.telescope").open(...) - end - local find_files_no_ignore = function() - local action_state = require("telescope.actions.state") - local line = action_state.get_current_line() - LazyVim.telescope("find_files", { no_ignore = true, default_text = line })() - end - local find_files_with_hidden = function() - local action_state = require("telescope.actions.state") - local line = action_state.get_current_line() - LazyVim.telescope("find_files", { hidden = true, default_text = line })() - end - - return { - defaults = { - prompt_prefix = " ", - selection_caret = " ", - -- open files in the first window that is an actual file. - -- use the current window if no other window is available. - get_selection_window = function() - local wins = vim.api.nvim_list_wins() - table.insert(wins, 1, vim.api.nvim_get_current_win()) - for _, win in ipairs(wins) do - local buf = vim.api.nvim_win_get_buf(win) - if vim.bo[buf].buftype == "" then - return win - end - end - return 0 - end, - mappings = { - i = { - [""] = open_with_trouble, - [""] = open_with_trouble, - [""] = find_files_no_ignore, - [""] = find_files_with_hidden, - [""] = actions.cycle_history_next, - [""] = actions.cycle_history_prev, - [""] = actions.preview_scrolling_down, - [""] = actions.preview_scrolling_up, - }, - n = { - ["q"] = actions.close, - }, - }, - }, - } - end, }, -- Flash enhances the built-in search functionality by showing labels @@ -310,69 +169,74 @@ return { }, }, - -- Flash Telescope config - { - "nvim-telescope/telescope.nvim", - optional = true, - opts = function(_, opts) - if not LazyVim.has("flash.nvim") then - return - end - local function flash(prompt_bufnr) - require("flash").jump({ - pattern = "^", - label = { after = { 0, 0 } }, - search = { - mode = "search", - exclude = { - function(win) - return vim.bo[vim.api.nvim_win_get_buf(win)].filetype ~= "TelescopeResults" - end, - }, - }, - action = function(match) - local picker = require("telescope.actions.state").get_current_picker(prompt_bufnr) - picker:set_selection(match.pos[1] - 1) - end, - }) - end - opts.defaults = vim.tbl_deep_extend("force", opts.defaults or {}, { - mappings = { n = { s = flash }, i = { [""] = flash } }, - }) - end, - }, - -- which-key helps you remember key bindings by showing a popup -- with the active keybindings of the command you started typing. { "folke/which-key.nvim", event = "VeryLazy", + opts_extend = { "spec" }, opts = { - plugins = { spelling = true }, - defaults = { - mode = { "n", "v" }, - ["g"] = { name = "+goto" }, - ["gs"] = { name = "+surround" }, - ["z"] = { name = "+fold" }, - ["]"] = { name = "+next" }, - ["["] = { name = "+prev" }, - [""] = { name = "+tabs" }, - ["b"] = { name = "+buffer" }, - ["c"] = { name = "+code" }, - ["f"] = { name = "+file/find" }, - ["g"] = { name = "+git" }, - ["gh"] = { name = "+hunks" }, - ["q"] = { name = "+quit/session" }, - ["s"] = { name = "+search" }, - ["u"] = { name = "+ui" }, - ["w"] = { name = "+windows" }, - ["x"] = { name = "+diagnostics/quickfix" }, + defaults = {}, + spec = { + { + mode = { "n", "v" }, + { "", group = "tabs" }, + { "c", group = "code" }, + { "f", group = "file/find" }, + { "g", group = "git" }, + { "gh", group = "hunks" }, + { "q", group = "quit/session" }, + { "s", group = "search" }, + { "u", group = "ui", icon = { icon = "󰙵 ", color = "cyan" } }, + { "x", group = "diagnostics/quickfix", icon = { icon = "󱖫 ", color = "green" } }, + { "[", group = "prev" }, + { "]", group = "next" }, + { "g", group = "goto" }, + { "gs", group = "surround" }, + { "z", group = "fold" }, + { + "b", + group = "buffer", + expand = function() + return require("which-key.extras").expand.buf() + end, + }, + { + "w", + group = "windows", + proxy = "", + expand = function() + return require("which-key.extras").expand.win() + end, + }, + -- better descriptions + { "gx", desc = "Open with system app" }, + }, + }, + }, + keys = { + { + "?", + function() + require("which-key").show({ global = false }) + end, + desc = "Buffer Keymaps (which-key)", + }, + { + "", + function() + require("which-key").show({ keys = "", loop = true }) + end, + desc = "Window Hydra Mode (which-key)", }, }, config = function(_, opts) local wk = require("which-key") wk.setup(opts) - wk.register(opts.defaults) + if not vim.tbl_isempty(opts.defaults) then + LazyVim.warn("which-key: opts.defaults is deprecated. Please use opts.spec instead.") + wk.register(opts.defaults) + end end, }, @@ -391,6 +255,13 @@ return { changedelete = { text = "▎" }, untracked = { text = "▎" }, }, + signs_staged = { + add = { text = "▎" }, + change = { text = "▎" }, + delete = { text = "" }, + topdelete = { text = "" }, + changedelete = { text = "▎" }, + }, on_attach = function(buffer) local gs = package.loaded.gitsigns @@ -399,8 +270,20 @@ return { end -- stylua: ignore start - map("n", "]h", function() gs.nav_hunk("next") end, "Next Hunk") - map("n", "[h", function() gs.nav_hunk("prev") end, "Prev Hunk") + map("n", "]h", function() + if vim.wo.diff then + vim.cmd.normal({ "]c", bang = true }) + else + gs.nav_hunk("next") + end + end, "Next Hunk") + map("n", "[h", function() + if vim.wo.diff then + vim.cmd.normal({ "[c", bang = true }) + else + gs.nav_hunk("prev") + end + end, "Prev Hunk") map("n", "]H", function() gs.nav_hunk("last") end, "Last Hunk") map("n", "[H", function() gs.nav_hunk("first") end, "First Hunk") map({ "n", "v" }, "ghs", ":Gitsigns stage_hunk", "Stage Hunk") @@ -410,6 +293,7 @@ return { map("n", "ghR", gs.reset_buffer, "Reset Buffer") map("n", "ghp", gs.preview_hunk_inline, "Preview Hunk Inline") map("n", "ghb", function() gs.blame_line({ full = true }) end, "Blame Line") + map("n", "ghB", function() gs.blame() end, "Blame Buffer") map("n", "ghd", gs.diffthis, "Diff This") map("n", "ghD", function() gs.diffthis("~") end, "Diff This ~") map({ "o", "x" }, "ih", ":Gitsigns select_hunk", "GitSigns Select Hunk") @@ -420,17 +304,19 @@ return { -- better diagnostics list and others { "folke/trouble.nvim", - cmd = { "TroubleToggle", "Trouble" }, - opts = { use_diagnostic_signs = true }, + cmd = { "Trouble" }, + opts = { + modes = { + lsp = { + win = { position = "right" }, + }, + }, + }, keys = { { "xx", "Trouble diagnostics toggle", desc = "Diagnostics (Trouble)" }, { "xX", "Trouble diagnostics toggle filter.buf=0", desc = "Buffer Diagnostics (Trouble)" }, - { "cs", "Trouble symbols toggle focus=false", desc = "Symbols (Trouble)" }, - { - "cS", - "Trouble lsp toggle focus=false win.position=right", - desc = "LSP references/definitions/... (Trouble)", - }, + { "cs", "Trouble symbols toggle", desc = "Symbols (Trouble)" }, + { "cS", "Trouble lsp toggle", desc = "LSP references/definitions/... (Trouble)" }, { "xL", "Trouble loclist toggle", desc = "Location List (Trouble)" }, { "xQ", "Trouble qflist toggle", desc = "Quickfix List (Trouble)" }, { @@ -470,7 +356,7 @@ return { "folke/todo-comments.nvim", cmd = { "TodoTrouble", "TodoTelescope" }, event = "LazyFile", - config = true, + opts = {}, -- stylua: ignore keys = { { "]t", function() require("todo-comments").jump_next() end, desc = "Next Todo Comment" }, @@ -481,4 +367,17 @@ return { { "sT", "TodoTelescope keywords=TODO,FIX,FIXME", desc = "Todo/Fix/Fixme" }, }, }, + + { + import = "lazyvim.plugins.extras.editor.fzf", + enabled = function() + return LazyVim.pick.want() == "fzf" + end, + }, + { + import = "lazyvim.plugins.extras.editor.telescope", + enabled = function() + return LazyVim.pick.want() == "telescope" + end, + }, } diff --git a/lua/lazyvim/plugins/extras/coding/copilot-chat.lua b/lua/lazyvim/plugins/extras/coding/copilot-chat.lua index c21c51d6..7eb2d666 100644 --- a/lua/lazyvim/plugins/extras/coding/copilot-chat.lua +++ b/lua/lazyvim/plugins/extras/coding/copilot-chat.lua @@ -1,3 +1,19 @@ +local M = {} + +---@param kind string +function M.pick(kind) + return function() + local actions = require("CopilotChat.actions") + local items = actions[kind .. "_actions"]() + if not items then + LazyVim.warn("No " .. kind .. " found on the current line") + return + end + local ok = pcall(require, "fzf-lua") + require("CopilotChat.integrations." .. (ok and "fzflua" or "telescope")).pick(items) + end +end + return { { "CopilotC-Nvim/CopilotChat.nvim", @@ -22,7 +38,8 @@ return { } end, keys = { - { "a", "", desc = "+ai" }, + { "", "", ft = "copilot-chat", desc = "Submit Prompt", remap = true }, + { "a", "", desc = "+ai", mode = { "n", "v" } }, { "aa", function() @@ -50,6 +67,10 @@ return { desc = "Quick Chat (CopilotChat)", mode = { "n", "v" }, }, + -- Show help actions with telescope + { "ad", M.pick("help"), desc = "Diagnostic Help (CopilotChat)", mode = { "n", "v" } }, + -- Show prompts actions with telescope + { "ap", M.pick("prompt"), desc = "Prompt Actions (CopilotChat)", mode = { "n", "v" } }, }, config = function(_, opts) local chat = require("CopilotChat") @@ -67,39 +88,6 @@ return { end, }, - -- Telescope integration - { - "nvim-telescope/telescope.nvim", - optional = true, - keys = { - -- Show help actions with telescope - { - "ad", - function() - local actions = require("CopilotChat.actions") - local help = actions.help_actions() - if not help then - LazyVim.warn("No diagnostics found on the current line") - return - end - require("CopilotChat.integrations.telescope").pick(help) - end, - desc = "Diagnostic Help (CopilotChat)", - mode = { "n", "v" }, - }, - -- Show prompts actions with telescope - { - "ap", - function() - local actions = require("CopilotChat.actions") - require("CopilotChat.integrations.telescope").pick(actions.prompt_actions()) - end, - desc = "Prompt Actions (CopilotChat)", - mode = { "n", "v" }, - }, - }, - }, - -- Edgy integration { "folke/edgy.nvim", diff --git a/lua/lazyvim/plugins/extras/coding/copilot.lua b/lua/lazyvim/plugins/extras/coding/copilot.lua index a9897107..8f0680ea 100644 --- a/lua/lazyvim/plugins/extras/coding/copilot.lua +++ b/lua/lazyvim/plugins/extras/coding/copilot.lua @@ -27,7 +27,7 @@ return { } table.insert(opts.sections.lualine_x, 2, { function() - local icon = require("lazyvim.config").icons.kinds.Copilot + local icon = LazyVim.config.icons.kinds.Copilot local status = require("copilot.api").status.data return icon .. (status.message or "") end, diff --git a/lua/lazyvim/plugins/extras/coding/luasnip.lua b/lua/lazyvim/plugins/extras/coding/luasnip.lua index f0aadc4f..47bd80c4 100644 --- a/lua/lazyvim/plugins/extras/coding/luasnip.lua +++ b/lua/lazyvim/plugins/extras/coding/luasnip.lua @@ -1,6 +1,7 @@ return { { "L3MON4D3/LuaSnip", + lazy = true, build = (not LazyVim.is_win()) and "echo 'NOTE: jsregexp is optional, so not a big deal if it fails to build'; make install_jsregexp" or nil, diff --git a/lua/lazyvim/plugins/extras/coding/tabnine.lua b/lua/lazyvim/plugins/extras/coding/tabnine.lua index a255120e..f02fccc9 100644 --- a/lua/lazyvim/plugins/extras/coding/tabnine.lua +++ b/lua/lazyvim/plugins/extras/coding/tabnine.lua @@ -42,7 +42,7 @@ return { optional = true, event = "VeryLazy", opts = function(_, opts) - local icon = require("lazyvim.config").icons.kinds.TabNine + local icon = LazyVim.config.icons.kinds.TabNine table.insert(opts.sections.lualine_x, 2, LazyVim.lualine.cmp_source("cmp_tabnine", icon)) end, }, diff --git a/lua/lazyvim/plugins/extras/coding/yanky.lua b/lua/lazyvim/plugins/extras/coding/yanky.lua index 27fa519a..c880aceb 100644 --- a/lua/lazyvim/plugins/extras/coding/yanky.lua +++ b/lua/lazyvim/plugins/extras/coding/yanky.lua @@ -8,13 +8,24 @@ return { highlight = { timer = 150 }, }, keys = { + { + "p", + function() + if LazyVim.pick.picker.name == "telescope" then + require("telescope").extensions.yank_history.yank_history({}) + else + vim.cmd([[YankyRingHistory]]) + end + end, + mode = { "n", "x" }, + desc = "Open Yank History", + }, -- stylua: ignore - { "p", function() require("telescope").extensions.yank_history.yank_history({ }) end, desc = "Open Yank History" }, { "y", "(YankyYank)", mode = { "n", "x" }, desc = "Yank Text" }, - { "p", "(YankyPutAfter)", mode = { "n", "x" }, desc = "Put Yanked Text After Cursor" }, - { "P", "(YankyPutBefore)", mode = { "n", "x" }, desc = "Put Yanked Text Before Cursor" }, - { "gp", "(YankyGPutAfter)", mode = { "n", "x" }, desc = "Put Yanked Text After Selection" }, - { "gP", "(YankyGPutBefore)", mode = { "n", "x" }, desc = "Put Yanked Text Before Selection" }, + { "p", "(YankyPutAfter)", mode = { "n", "x" }, desc = "Put Text After Cursor" }, + { "P", "(YankyPutBefore)", mode = { "n", "x" }, desc = "Put Text Before Cursor" }, + { "gp", "(YankyGPutAfter)", mode = { "n", "x" }, desc = "Put Text After Selection" }, + { "gP", "(YankyGPutBefore)", mode = { "n", "x" }, desc = "Put Text Before Selection" }, { "[y", "(YankyCycleForward)", desc = "Cycle Forward Through Yank History" }, { "]y", "(YankyCycleBackward)", desc = "Cycle Backward Through Yank History" }, { "]p", "(YankyPutIndentAfterLinewise)", desc = "Put Indented After Cursor (Linewise)" }, diff --git a/lua/lazyvim/plugins/extras/dap/core.lua b/lua/lazyvim/plugins/extras/dap/core.lua index b7a088c1..67a3d71b 100644 --- a/lua/lazyvim/plugins/extras/dap/core.lua +++ b/lua/lazyvim/plugins/extras/dap/core.lua @@ -17,33 +17,7 @@ return { desc = "Debugging support. Requires language specific adapters to be configured. (see lang extras)", dependencies = { - - -- fancy UI for the debugger - { - "rcarriga/nvim-dap-ui", - dependencies = { "nvim-neotest/nvim-nio" }, - -- stylua: ignore - keys = { - { "du", function() require("dapui").toggle({ }) end, desc = "Dap UI" }, - { "de", function() require("dapui").eval() end, desc = "Eval", mode = {"n", "v"} }, - }, - opts = {}, - config = function(_, opts) - local dap = require("dap") - local dapui = require("dapui") - dapui.setup(opts) - dap.listeners.after.event_initialized["dapui_config"] = function() - dapui.open({}) - end - dap.listeners.before.event_terminated["dapui_config"] = function() - dapui.close({}) - end - dap.listeners.before.event_exited["dapui_config"] = function() - dapui.close({}) - end - end, - }, - + "rcarriga/nvim-dap-ui", -- virtual text for the debugger { "theHamsta/nvim-dap-virtual-text", @@ -74,10 +48,14 @@ return { }, config = function() - local Config = require("lazyvim.config") + -- load mason-nvim-dap here, after all adapters have been setup + if LazyVim.has("mason-nvim-dap.nvim") then + require("mason-nvim-dap").setup(LazyVim.opts("mason-nvim-dap.nvim")) + end + vim.api.nvim_set_hl(0, "DapStoppedLine", { default = true, link = "Visual" }) - for name, sign in pairs(Config.icons.dap) do + for name, sign in pairs(LazyVim.config.icons.dap) do sign = type(sign) == "table" and sign or { sign } vim.fn.sign_define( "Dap" .. name, @@ -91,6 +69,37 @@ return { vscode.json_decode = function(str) return vim.json.decode(json.json_strip_comments(str)) end + + -- Extends dap.configurations with entries read from .vscode/launch.json + if vim.fn.filereadable(".vscode/launch.json") then + vscode.load_launchjs() + end + end, + }, + + -- fancy UI for the debugger + { + "rcarriga/nvim-dap-ui", + dependencies = { "nvim-neotest/nvim-nio" }, + -- stylua: ignore + keys = { + { "du", function() require("dapui").toggle({ }) end, desc = "Dap UI" }, + { "de", function() require("dapui").eval() end, desc = "Eval", mode = {"n", "v"} }, + }, + opts = {}, + config = function(_, opts) + local dap = require("dap") + local dapui = require("dapui") + dapui.setup(opts) + dap.listeners.after.event_initialized["dapui_config"] = function() + dapui.open({}) + end + dap.listeners.before.event_terminated["dapui_config"] = function() + dapui.close({}) + end + dap.listeners.before.event_exited["dapui_config"] = function() + dapui.close({}) + end end, }, @@ -114,5 +123,7 @@ return { -- Update this to ensure that you have the debuggers for the langs you want }, }, + -- mason-nvim-dap is loaded when nvim-dap loads + config = function() end, }, } diff --git a/lua/lazyvim/plugins/extras/editor/aerial.lua b/lua/lazyvim/plugins/extras/editor/aerial.lua index ad527aae..d2486c22 100644 --- a/lua/lazyvim/plugins/extras/editor/aerial.lua +++ b/lua/lazyvim/plugins/extras/editor/aerial.lua @@ -1,12 +1,10 @@ -local Config = require("lazyvim.config") - return { desc = "Aerial Symbol Browser", { "stevearc/aerial.nvim", event = "LazyFile", opts = function() - local icons = vim.deepcopy(Config.icons.kinds) + local icons = vim.deepcopy(LazyVim.config.icons.kinds) -- HACK: fix lua's weird choice for `Package` for control -- structures like if/else/for/etc. @@ -14,8 +12,8 @@ return { ---@type table|false local filter_kind = false - if Config.kind_filter then - filter_kind = assert(vim.deepcopy(Config.kind_filter)) + if LazyVim.config.kind_filter then + filter_kind = assert(vim.deepcopy(LazyVim.config.kind_filter)) filter_kind._ = filter_kind.default filter_kind.default = nil end diff --git a/lua/lazyvim/plugins/extras/editor/dial.lua b/lua/lazyvim/plugins/extras/editor/dial.lua index cc262a33..5d2dcaa1 100644 --- a/lua/lazyvim/plugins/extras/editor/dial.lua +++ b/lua/lazyvim/plugins/extras/editor/dial.lua @@ -1,6 +1,4 @@ local M = {} ----@type table> -M.dials_by_ft = {} ---@param increment boolean ---@param g? boolean @@ -9,7 +7,7 @@ function M.dial(increment, g) -- Use visual commands for VISUAL 'v', VISUAL LINE 'V' and VISUAL BLOCK '\22' local is_visual = mode == "v" or mode == "V" or mode == "\22" local func = (increment and "inc" or "dec") .. (g and "_g" or "_") .. (is_visual and "visual" or "normal") - local group = M.dials_by_ft[vim.bo.filetype] or "default" + local group = vim.g.dials_by_ft[vim.bo.filetype] or "default" return require("dial.map")[func](group) end @@ -110,21 +108,26 @@ return { scss = "css", typescript = "typescript", typescriptreact = "typescript", + yaml = "yaml", }, groups = { default = { augend.integer.alias.decimal, -- nonnegative decimal number (0, 1, 2, 3, ...) augend.integer.alias.hex, -- nonnegative hex number (0x01, 0x1a1f, etc.) augend.date.alias["%Y/%m/%d"], -- date (2022/02/19, etc.) + ordinal_numbers, + weekdays, + months, }, typescript = { augend.integer.alias.decimal, -- nonnegative and negative decimal number augend.constant.alias.bool, -- boolean value (true <-> false) logical_alias, augend.constant.new({ elements = { "let", "const" } }), - ordinal_numbers, - weekdays, - months, + }, + yaml = { + augend.integer.alias.decimal, -- nonnegative and negative decimal number + augend.constant.alias.bool, -- boolean value (true <-> false) }, css = { augend.integer.alias.decimal, -- nonnegative and negative decimal number @@ -137,9 +140,6 @@ return { }, markdown = { augend.misc.alias.markdown_header, - ordinal_numbers, - weekdays, - months, }, json = { augend.integer.alias.decimal, -- nonnegative and negative decimal number @@ -153,23 +153,17 @@ return { word = true, -- if false, "sand" is incremented into "sor", "doctor" into "doctand", etc. cyclic = true, -- "or" is incremented into "and". }), - ordinal_numbers, - weekdays, - months, }, python = { augend.integer.alias.decimal, -- nonnegative and negative decimal number capitalized_boolean, logical_alias, - ordinal_numbers, - weekdays, - months, }, }, } end, config = function(_, opts) require("dial.config").augends:register_group(opts.groups) - M.dials_by_ft = opts.dials_by_ft + vim.g.dials_by_ft = opts.dials_by_ft end, } diff --git a/lua/lazyvim/plugins/extras/editor/fzf.lua b/lua/lazyvim/plugins/extras/editor/fzf.lua new file mode 100644 index 00000000..e23af81b --- /dev/null +++ b/lua/lazyvim/plugins/extras/editor/fzf.lua @@ -0,0 +1,294 @@ +if lazyvim_docs then + -- In case you don't want to use `:LazyExtras`, + -- then you need to set the option below. + vim.g.lazyvim_picker = "fzf" +end + +---@class FzfLuaOpts: lazyvim.util.pick.Opts +---@field cmd string? + +---@type LazyPicker +local picker = { + name = "fzf", + commands = { + files = "files", + }, + + ---@param command string + ---@param opts? FzfLuaOpts + open = function(command, opts) + opts = opts or {} + if opts.cmd == nil and command == "git_files" and opts.show_untracked then + opts.cmd = "git ls-files --exclude-standard --cached --others" + end + return require("fzf-lua")[command](opts) + end, +} +if not LazyVim.pick.register(picker) then + return {} +end + +local function symbols_filter(entry, ctx) + if ctx.symbols_filter == nil then + ctx.symbols_filter = LazyVim.config.get_kind_filter(ctx.bufnr) or false + end + if ctx.symbols_filter == false then + return true + end + return vim.tbl_contains(ctx.symbols_filter, entry.kind) +end + +return { + desc = "Awesome picker for FZF (alternative to Telescope)", + recommended = true, + { + "ibhagwan/fzf-lua", + cmd = "FzfLua", + opts = function(_, opts) + local config = require("fzf-lua.config") + local actions = require("fzf-lua.actions") + + -- Quickfix + config.defaults.keymap.fzf["ctrl-q"] = "select-all+accept" + config.defaults.keymap.fzf["ctrl-u"] = "half-page-up" + config.defaults.keymap.fzf["ctrl-d"] = "half-page-down" + config.defaults.keymap.fzf["ctrl-x"] = "jump" + config.defaults.keymap.fzf["ctrl-f"] = "preview-page-down" + config.defaults.keymap.fzf["ctrl-b"] = "preview-page-up" + config.defaults.keymap.builtin[""] = "preview-page-down" + config.defaults.keymap.builtin[""] = "preview-page-up" + + -- Trouble + if LazyVim.has("trouble.nvim") then + config.defaults.actions.files["ctrl-t"] = require("trouble.sources.fzf").actions.open + end + + -- Toggle root dir / cwd + config.defaults.actions.files["ctrl-r"] = function(_, ctx) + local o = vim.deepcopy(ctx.__call_opts) + o.root = o.root == false + o.cwd = nil + o.buf = ctx.__CTX.bufnr + LazyVim.pick.open(ctx.__INFO.cmd, o) + end + config.defaults.actions.files["alt-c"] = config.defaults.actions.files["ctrl-r"] + config.set_action_helpstr(config.defaults.actions.files["ctrl-r"], "toggle-root-dir") + + -- use the same prompt for all + local defaults = require("fzf-lua.profiles.default-title") + local function fix(t) + t.prompt = t.prompt ~= nil and " " or nil + for _, v in pairs(t) do + if type(v) == "table" then + fix(v) + end + end + end + fix(defaults) + + local img_previewer ---@type string[]? + for _, v in ipairs({ + { cmd = "ueberzug", args = {} }, + { cmd = "chafa", args = { "{file}", "--format=symbols" } }, + { cmd = "viu", args = { "-b" } }, + }) do + if vim.fn.executable(v.cmd) == 1 then + img_previewer = vim.list_extend({ v.cmd }, v.args) + break + end + end + + return vim.tbl_deep_extend("force", defaults, { + fzf_colors = true, + fzf_opts = { + ["--no-scrollbar"] = true, + }, + defaults = { + -- formatter = "path.filename_first", + formatter = "path.dirname_first", + }, + previewers = { + builtin = { + extensions = { + ["png"] = img_previewer, + ["jpg"] = img_previewer, + ["jpeg"] = img_previewer, + ["gif"] = img_previewer, + ["webp"] = img_previewer, + }, + ueberzug_scaler = "fit_contain", + }, + }, + -- Custom LazyVim option to configure vim.ui.select + ui_select = function(fzf_opts, items) + return vim.tbl_deep_extend("force", fzf_opts, { + prompt = " ", + winopts = { + title = " " .. vim.trim((fzf_opts.prompt or "Select"):gsub("%s*:%s*$", "")) .. " ", + title_pos = "center", + }, + }, fzf_opts.kind == "codeaction" and { + winopts = { + layout = "vertical", + -- height is number of items minus 15 lines for the preview, with a max of 80% screen height + height = math.floor(math.min(vim.o.lines * 0.8 - 16, #items + 2) + 0.5) + 16, + width = 0.5, + preview = not vim.tbl_isempty(LazyVim.lsp.get_clients({ bufnr = 0, name = "vtsls" })) and { + layout = "vertical", + vertical = "down:15,border-top", + hidden = "hidden", + } or { + layout = "vertical", + vertical = "down:15,border-top", + }, + }, + } or { + winopts = { + width = 0.5, + -- height is number of items, with a max of 80% screen height + height = math.floor(math.min(vim.o.lines * 0.8, #items + 2) + 0.5), + }, + }) + end, + winopts = { + width = 0.8, + height = 0.8, + row = 0.5, + col = 0.5, + preview = { + scrollchars = { "┃", "" }, + }, + }, + files = { + cwd_prompt = false, + actions = { + ["alt-i"] = { actions.toggle_ignore }, + ["alt-h"] = { actions.toggle_hidden }, + }, + }, + grep = { + actions = { + ["alt-i"] = { actions.toggle_ignore }, + ["alt-h"] = { actions.toggle_hidden }, + }, + }, + lsp = { + symbols = { + symbol_hl = function(s) + return "TroubleIcon" .. s + end, + symbol_fmt = function(s) + return s:lower() .. "\t" + end, + child_prefix = false, + }, + code_actions = { + previewer = vim.fn.executable("delta") == 1 and "codeaction_native" or nil, + }, + }, + }) + end, + config = function(_, opts) + require("fzf-lua").setup(opts) + end, + init = function() + LazyVim.on_very_lazy(function() + vim.ui.select = function(...) + require("lazy").load({ plugins = { "fzf-lua" } }) + local opts = LazyVim.opts("fzf-lua") or {} + require("fzf-lua").register_ui_select(opts.ui_select or nil) + return vim.ui.select(...) + end + end) + end, + keys = { + { "", "", ft = "fzf", mode = "t", nowait = true }, + { "", "", ft = "fzf", mode = "t", nowait = true }, + { + ",", + "FzfLua buffers sort_mru=true sort_lastused=true", + desc = "Switch Buffer", + }, + { "/", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" }, + { ":", "FzfLua command_history", desc = "Command History" }, + { "", LazyVim.pick("files"), desc = "Find Files (Root Dir)" }, + -- find + { "fb", "FzfLua buffers sort_mru=true sort_lastused=true", desc = "Buffers" }, + { "fc", LazyVim.pick.config_files(), desc = "Find Config File" }, + { "ff", LazyVim.pick("files"), desc = "Find Files (Root Dir)" }, + { "fF", LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" }, + { "fg", "FzfLua git_files", desc = "Find Files (git-files)" }, + { "fr", "FzfLua oldfiles", desc = "Recent" }, + { "fR", LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" }, + -- git + { "gc", "FzfLua git_commits", desc = "Commits" }, + { "gs", "FzfLua git_status", desc = "Status" }, + -- search + { 's"', "FzfLua registers", desc = "Registers" }, + { "sa", "FzfLua autocmds", desc = "Auto Commands" }, + { "sb", "FzfLua grep_curbuf", desc = "Buffer" }, + { "sc", "FzfLua command_history", desc = "Command History" }, + { "sC", "FzfLua commands", desc = "Commands" }, + { "sd", "FzfLua diagnostics_document", desc = "Document Diagnostics" }, + { "sD", "FzfLua diagnostics_workspace", desc = "Workspace Diagnostics" }, + { "sg", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" }, + { "sG", LazyVim.pick("live_grep", { root = false }), desc = "Grep (cwd)" }, + { "sh", "FzfLua help_tags", desc = "Help Pages" }, + { "sH", "FzfLua highlights", desc = "Search Highlight Groups" }, + { "sj", "FzfLua jumps", desc = "Jumplist" }, + { "sk", "FzfLua keymaps", desc = "Key Maps" }, + { "sl", "FzfLua loclist", desc = "Location List" }, + { "sM", "FzfLua man_pages", desc = "Man Pages" }, + { "sm", "FzfLua marks", desc = "Jump to Mark" }, + { "sR", "FzfLua resume", desc = "Resume" }, + { "sq", "FzfLua quickfix", desc = "Quickfix List" }, + { "sw", LazyVim.pick("grep_cword"), desc = "Word (Root Dir)" }, + { "sW", LazyVim.pick("grep_cword", { root = false }), desc = "Word (cwd)" }, + { "sw", LazyVim.pick("grep_visual"), mode = "v", desc = "Selection (Root Dir)" }, + { "sW", LazyVim.pick("grep_visual", { root = false }), mode = "v", desc = "Selection (cwd)" }, + { "uC", LazyVim.pick("colorschemes"), desc = "Colorscheme with Preview" }, + { + "ss", + function() + require("fzf-lua").lsp_document_symbols({ + regex_filter = symbols_filter, + }) + end, + desc = "Goto Symbol", + }, + { + "sS", + function() + require("fzf-lua").lsp_live_workspace_symbols({ + regex_filter = symbols_filter, + }) + end, + desc = "Goto Symbol (Workspace)", + }, + }, + }, + + { + "folke/todo-comments.nvim", + optional = true, + -- stylua: ignore + keys = { + { "st", function() require("todo-comments.fzf").todo() end, desc = "Todo" }, + { "sT", function () require("todo-comments.fzf").todo({ keywords = { "TODO", "FIX", "FIXME" } }) end, desc = "Todo/Fix/Fixme" }, + }, + }, + + { + "neovim/nvim-lspconfig", + opts = function() + local Keys = require("lazyvim.plugins.lsp.keymaps").get() + -- stylua: ignore + vim.list_extend(Keys, { + { "gd", "FzfLua lsp_definitions jump_to_single_result=true ignore_current_line=true", desc = "Goto Definition", has = "definition" }, + { "gr", "FzfLua lsp_references jump_to_single_result=true ignore_current_line=true", desc = "References", nowait = true }, + { "gI", "FzfLua lsp_implementations jump_to_single_result=true ignore_current_line=true", desc = "Goto Implementation" }, + { "gy", "FzfLua lsp_typedefs jump_to_single_result=true ignore_current_line=true", desc = "Goto T[y]pe Definition" }, + }) + end, + }, +} diff --git a/lua/lazyvim/plugins/extras/editor/leap.lua b/lua/lazyvim/plugins/extras/editor/leap.lua index cf6e7478..19c8b331 100644 --- a/lua/lazyvim/plugins/extras/editor/leap.lua +++ b/lua/lazyvim/plugins/extras/editor/leap.lua @@ -7,10 +7,10 @@ return { "ggandor/flit.nvim", enabled = true, keys = function() - ---@type LazyKeys[] + ---@type LazyKeysSpec[] local ret = {} for _, key in ipairs({ "f", "F", "t", "T" }) do - ret[#ret + 1] = { key, mode = { "n", "x", "o" }, desc = key } + ret[#ret + 1] = { key, mode = { "n", "x", "o" } } end return ret end, diff --git a/lua/lazyvim/plugins/extras/editor/mini-files.lua b/lua/lazyvim/plugins/extras/editor/mini-files.lua index 2261567d..7f677ebf 100644 --- a/lua/lazyvim/plugins/extras/editor/mini-files.lua +++ b/lua/lazyvim/plugins/extras/editor/mini-files.lua @@ -1,14 +1,6 @@ return { "echasnovski/mini.files", opts = { - mappings = { - toggle_hidden = "g.", - change_cwd = "gc", - go_in_horizontal = "s", - go_in_vertical = "v", - go_in_horizontal_plus = "S", - go_in_vertical_plus = "V", - }, windows = { preview = true, width_focus = 30, @@ -90,17 +82,22 @@ return { vim.keymap.set( "n", - opts.mappings.toggle_hidden, + opts.mappings and opts.mappings.toggle_hidden or "g.", toggle_dotfiles, { buffer = buf_id, desc = "Toggle hidden files" } ) - vim.keymap.set("n", opts.mappings.change_cwd, files_set_cwd, { buffer = args.data.buf_id, desc = "Set cwd" }) + vim.keymap.set( + "n", + opts.mappings and opts.mappings.change_cwd or "gc", + files_set_cwd, + { buffer = args.data.buf_id, desc = "Set cwd" } + ) - map_split(buf_id, opts.mappings.go_in_horizontal, "horizontal", false) - map_split(buf_id, opts.mappings.go_in_vertical, "vertical", false) - map_split(buf_id, opts.mappings.go_in_horizontal_plus, "horizontal", true) - map_split(buf_id, opts.mappings.go_in_vertical_plus, "vertical", true) + map_split(buf_id, opts.mappings and opts.mappings.go_in_horizontal or "s", "horizontal", false) + map_split(buf_id, opts.mappings and opts.mappings.go_in_vertical or "v", "vertical", false) + map_split(buf_id, opts.mappings and opts.mappings.go_in_horizontal_plus or "S", "horizontal", true) + map_split(buf_id, opts.mappings and opts.mappings.go_in_vertical_plus or "V", "vertical", true) end, }) diff --git a/lua/lazyvim/plugins/extras/editor/navic.lua b/lua/lazyvim/plugins/extras/editor/navic.lua index e89bc11f..642a4a99 100644 --- a/lua/lazyvim/plugins/extras/editor/navic.lua +++ b/lua/lazyvim/plugins/extras/editor/navic.lua @@ -18,7 +18,7 @@ return { separator = " ", highlight = true, depth_limit = 5, - icons = require("lazyvim.config").icons.kinds, + icons = LazyVim.config.icons.kinds, lazy_update_context = true, } end, diff --git a/lua/lazyvim/plugins/extras/editor/outline.lua b/lua/lazyvim/plugins/extras/editor/outline.lua index 07c46705..5b5a5831 100644 --- a/lua/lazyvim/plugins/extras/editor/outline.lua +++ b/lua/lazyvim/plugins/extras/editor/outline.lua @@ -12,27 +12,23 @@ return { keys = { { "cs", "Outline", desc = "Toggle Outline" } }, cmd = "Outline", opts = function() - local Config = require("lazyvim.config") local defaults = require("outline.config").defaults local opts = { - symbols = {}, - symbol_blacklist = {}, + symbols = { + icons = {}, + filter = vim.deepcopy(LazyVim.config.kind_filter), + }, + keymaps = { + up_and_jump = "", + down_and_jump = "", + }, } - local filter = Config.kind_filter - if type(filter) == "table" then - filter = filter.default - if type(filter) == "table" then - for kind, symbol in pairs(defaults.symbols) do - opts.symbols[kind] = { - icon = Config.icons.kinds[kind] or symbol.icon, - hl = symbol.hl, - } - if not vim.tbl_contains(filter, kind) then - table.insert(opts.symbol_blacklist, kind) - end - end - end + for kind, symbol in pairs(defaults.symbols.icons) do + opts.symbols.icons[kind] = { + icon = LazyVim.config.icons.kinds[kind] or symbol.icon, + hl = symbol.hl, + } end return opts end, diff --git a/lua/lazyvim/plugins/extras/editor/overseer.lua b/lua/lazyvim/plugins/extras/editor/overseer.lua new file mode 100644 index 00000000..373c0029 --- /dev/null +++ b/lua/lazyvim/plugins/extras/editor/overseer.lua @@ -0,0 +1,102 @@ +return { + { + "catppuccin", + optional = true, + opts = { + integrations = { overseer = true }, + }, + }, + { + "stevearc/overseer.nvim", + cmd = { + "OverseerOpen", + "OverseerClose", + "OverseerToggle", + "OverseerSaveBundle", + "OverseerLoadBundle", + "OverseerDeleteBundle", + "OverseerRunCmd", + "OverseerRun", + "OverseerInfo", + "OverseerBuild", + "OverseerQuickAction", + "OverseerTaskAction", + "OverseerClearCache", + }, + opts = { + dap = false, + task_list = { + bindings = { + [""] = false, + [""] = false, + [""] = false, + [""] = false, + }, + }, + form = { + win_opts = { + winblend = 0, + }, + }, + confirm = { + win_opts = { + winblend = 0, + }, + }, + task_win = { + win_opts = { + winblend = 0, + }, + }, + }, + -- stylua: ignore + keys = { + { "ow", "OverseerToggle", desc = "Task list" }, + { "oo", "OverseerRun", desc = "Run task" }, + { "oq", "OverseerQuickAction", desc = "Action recent task" }, + { "oi", "OverseerInfo", desc = "Overseer Info" }, + { "ob", "OverseerBuild", desc = "Task builder" }, + { "ot", "OverseerTaskAction", desc = "Task action" }, + { "oc", "OverseerClearCache", desc = "Clear cache" }, + }, + }, + { + "folke/which-key.nvim", + optional = true, + opts = { + spec = { + { "o", group = "overseer" }, + }, + }, + }, + { + "folke/edgy.nvim", + optional = true, + opts = function(_, opts) + opts.right = opts.right or {} + table.insert(opts.right, { + title = "Overseer", + ft = "OverseerList", + open = function() + require("overseer").open() + end, + }) + end, + }, + { + "nvim-neotest/neotest", + optional = true, + opts = function(_, opts) + opts = opts or {} + opts.consumers = opts.consumers or {} + opts.consumers.overseer = require("neotest.consumers.overseer") + end, + }, + { + "mfussenegger/nvim-dap", + optional = true, + opts = function() + require("overseer").enable_dap() + end, + }, +} diff --git a/lua/lazyvim/plugins/extras/editor/refactoring.lua b/lua/lazyvim/plugins/extras/editor/refactoring.lua index 9d8f8f9c..29920347 100644 --- a/lua/lazyvim/plugins/extras/editor/refactoring.lua +++ b/lua/lazyvim/plugins/extras/editor/refactoring.lua @@ -1,3 +1,24 @@ +local pick = function() + if LazyVim.pick.picker.name == "telescope" then + return require("telescope").extensions.refactoring.refactors() + elseif LazyVim.pick.picker.name == "fzf" then + local fzf_lua = require("fzf-lua") + local results = require("refactoring").get_refactors() + local refactoring = require("refactoring") + + local opts = { + fzf_opts = {}, + fzf_colors = true, + actions = { + ["default"] = function(selected) + refactoring.refactor(selected[1]) + end, + }, + } + fzf_lua.fzf_exec(results, opts) + end +end + return { { "ThePrimeagen/refactoring.nvim", @@ -10,9 +31,7 @@ return { { "r", "", desc = "+refactor", mode = { "n", "v" } }, { "rs", - function() - require("telescope").extensions.refactoring.refactors() - end, + pick, mode = "v", desc = "Refactor", }, diff --git a/lua/lazyvim/plugins/extras/editor/telescope.lua b/lua/lazyvim/plugins/extras/editor/telescope.lua new file mode 100644 index 00000000..11cfef1b --- /dev/null +++ b/lua/lazyvim/plugins/extras/editor/telescope.lua @@ -0,0 +1,294 @@ +if lazyvim_docs then + -- In case you don't want to use `:LazyExtras`, + -- then you need to set the option below. + vim.g.lazyvim_picker = "telescope" +end + +local have_make = vim.fn.executable("make") == 1 +local have_cmake = vim.fn.executable("cmake") == 1 + +---@type LazyPicker +local picker = { + name = "telescope", + commands = { + files = "find_files", + }, + -- this will return a function that calls telescope. + -- cwd will default to lazyvim.util.get_root + -- for `files`, git_files or find_files will be chosen depending on .git + ---@param builtin string + ---@param opts? lazyvim.util.pick.Opts + open = function(builtin, opts) + opts = opts or {} + opts.follow = opts.follow ~= false + if opts.cwd and opts.cwd ~= vim.uv.cwd() then + local function open_cwd_dir() + local action_state = require("telescope.actions.state") + local line = action_state.get_current_line() + LazyVim.pick.open( + builtin, + vim.tbl_deep_extend("force", {}, opts or {}, { + root = false, + default_text = line, + }) + ) + end + ---@diagnostic disable-next-line: inject-field + opts.attach_mappings = function(_, map) + -- opts.desc is overridden by telescope, until it's changed there is this fix + map("i", "", open_cwd_dir, { desc = "Open cwd Directory" }) + return true + end + end + + require("telescope.builtin")[builtin](opts) + end, +} +if not LazyVim.pick.register(picker) then + return {} +end + +return { + -- Fuzzy finder. + -- The default key bindings to find files will use Telescope's + -- `find_files` or `git_files` depending on whether the + -- directory is a git repo. + { + "nvim-telescope/telescope.nvim", + cmd = "Telescope", + enabled = function() + return LazyVim.pick.want() == "telescope" + end, + version = false, -- telescope did only one release, so use HEAD for now + dependencies = { + { + "nvim-telescope/telescope-fzf-native.nvim", + build = have_make and "make" + or "cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release && cmake --build build --config Release && cmake --install build --prefix build", + enabled = have_make or have_cmake, + config = function(plugin) + LazyVim.on_load("telescope.nvim", function() + local ok, err = pcall(require("telescope").load_extension, "fzf") + if not ok then + local lib = plugin.dir .. "/build/libfzf." .. (LazyVim.is_win() and "dll" or "so") + if not vim.uv.fs_stat(lib) then + LazyVim.warn("`telescope-fzf-native.nvim` not built. Rebuilding...") + require("lazy").build({ plugins = { plugin }, show = false }):wait(function() + LazyVim.info("Rebuilding `telescope-fzf-native.nvim` done.\nPlease restart Neovim.") + end) + else + LazyVim.error("Failed to load `telescope-fzf-native.nvim`:\n" .. err) + end + end + end) + end, + }, + }, + keys = { + { + ",", + "Telescope buffers sort_mru=true sort_lastused=true", + desc = "Switch Buffer", + }, + { "/", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" }, + { ":", "Telescope command_history", desc = "Command History" }, + { "", LazyVim.pick("files"), desc = "Find Files (Root Dir)" }, + -- find + { "fb", "Telescope buffers sort_mru=true sort_lastused=true", desc = "Buffers" }, + { "fc", LazyVim.pick.config_files(), desc = "Find Config File" }, + { "ff", LazyVim.pick("files"), desc = "Find Files (Root Dir)" }, + { "fF", LazyVim.pick("files", { root = false }), desc = "Find Files (cwd)" }, + { "fg", "Telescope git_files", desc = "Find Files (git-files)" }, + { "fr", "Telescope oldfiles", desc = "Recent" }, + { "fR", LazyVim.pick("oldfiles", { cwd = vim.uv.cwd() }), desc = "Recent (cwd)" }, + -- git + { "gc", "Telescope git_commits", desc = "Commits" }, + { "gs", "Telescope git_status", desc = "Status" }, + -- search + { 's"', "Telescope registers", desc = "Registers" }, + { "sa", "Telescope autocommands", desc = "Auto Commands" }, + { "sb", "Telescope current_buffer_fuzzy_find", desc = "Buffer" }, + { "sc", "Telescope command_history", desc = "Command History" }, + { "sC", "Telescope commands", desc = "Commands" }, + { "sd", "Telescope diagnostics bufnr=0", desc = "Document Diagnostics" }, + { "sD", "Telescope diagnostics", desc = "Workspace Diagnostics" }, + { "sg", LazyVim.pick("live_grep"), desc = "Grep (Root Dir)" }, + { "sG", LazyVim.pick("live_grep", { root = false }), desc = "Grep (cwd)" }, + { "sh", "Telescope help_tags", desc = "Help Pages" }, + { "sH", "Telescope highlights", desc = "Search Highlight Groups" }, + { "sj", "Telescope jumplist", desc = "Jumplist" }, + { "sk", "Telescope keymaps", desc = "Key Maps" }, + { "sl", "Telescope loclist", desc = "Location List" }, + { "sM", "Telescope man_pages", desc = "Man Pages" }, + { "sm", "Telescope marks", desc = "Jump to Mark" }, + { "so", "Telescope vim_options", desc = "Options" }, + { "sR", "Telescope resume", desc = "Resume" }, + { "sq", "Telescope quickfix", desc = "Quickfix List" }, + { "sw", LazyVim.pick("grep_string", { word_match = "-w" }), desc = "Word (Root Dir)" }, + { "sW", LazyVim.pick("grep_string", { root = false, word_match = "-w" }), desc = "Word (cwd)" }, + { "sw", LazyVim.pick("grep_string"), mode = "v", desc = "Selection (Root Dir)" }, + { "sW", LazyVim.pick("grep_string", { root = false }), mode = "v", desc = "Selection (cwd)" }, + { "uC", LazyVim.pick("colorscheme", { enable_preview = true }), desc = "Colorscheme with Preview" }, + { + "ss", + function() + require("telescope.builtin").lsp_document_symbols({ + symbols = LazyVim.config.get_kind_filter(), + }) + end, + desc = "Goto Symbol", + }, + { + "sS", + function() + require("telescope.builtin").lsp_dynamic_workspace_symbols({ + symbols = LazyVim.config.get_kind_filter(), + }) + end, + desc = "Goto Symbol (Workspace)", + }, + }, + opts = function() + local actions = require("telescope.actions") + + local open_with_trouble = function(...) + return require("trouble.sources.telescope").open(...) + end + local find_files_no_ignore = function() + local action_state = require("telescope.actions.state") + local line = action_state.get_current_line() + LazyVim.pick("find_files", { no_ignore = true, default_text = line })() + end + local find_files_with_hidden = function() + local action_state = require("telescope.actions.state") + local line = action_state.get_current_line() + LazyVim.pick("find_files", { hidden = true, default_text = line })() + end + + local function find_command() + if 1 == vim.fn.executable("rg") then + return { "rg", "--files", "--color", "never", "-g", "!.git" } + elseif 1 == vim.fn.executable("fd") then + return { "fd", "--type", "f", "--color", "never", "-E", ".git" } + elseif 1 == vim.fn.executable("fdfind") then + return { "fdfind", "--type", "f", "--color", "never", "-E", ".git" } + elseif 1 == vim.fn.executable("find") and vim.fn.has("win32") == 0 then + return { "find", ".", "-type", "f" } + elseif 1 == vim.fn.executable("where") then + return { "where", "/r", ".", "*" } + end + end + + return { + defaults = { + prompt_prefix = " ", + selection_caret = " ", + -- open files in the first window that is an actual file. + -- use the current window if no other window is available. + get_selection_window = function() + local wins = vim.api.nvim_list_wins() + table.insert(wins, 1, vim.api.nvim_get_current_win()) + for _, win in ipairs(wins) do + local buf = vim.api.nvim_win_get_buf(win) + if vim.bo[buf].buftype == "" then + return win + end + end + return 0 + end, + mappings = { + i = { + [""] = open_with_trouble, + [""] = open_with_trouble, + [""] = find_files_no_ignore, + [""] = find_files_with_hidden, + [""] = actions.cycle_history_next, + [""] = actions.cycle_history_prev, + [""] = actions.preview_scrolling_down, + [""] = actions.preview_scrolling_up, + }, + n = { + ["q"] = actions.close, + }, + }, + }, + pickers = { + find_files = { + find_command = find_command, + hidden = true, + }, + }, + } + end, + }, + + -- Flash Telescope config + { + "nvim-telescope/telescope.nvim", + optional = true, + opts = function(_, opts) + if not LazyVim.has("flash.nvim") then + return + end + local function flash(prompt_bufnr) + require("flash").jump({ + pattern = "^", + label = { after = { 0, 0 } }, + search = { + mode = "search", + exclude = { + function(win) + return vim.bo[vim.api.nvim_win_get_buf(win)].filetype ~= "TelescopeResults" + end, + }, + }, + action = function(match) + local picker = require("telescope.actions.state").get_current_picker(prompt_bufnr) + picker:set_selection(match.pos[1] - 1) + end, + }) + end + opts.defaults = vim.tbl_deep_extend("force", opts.defaults or {}, { + mappings = { n = { s = flash }, i = { [""] = flash } }, + }) + end, + }, + + -- better vim.ui with telescope + { + "stevearc/dressing.nvim", + lazy = true, + enabled = function() + return LazyVim.pick.want() == "telescope" + end, + init = function() + ---@diagnostic disable-next-line: duplicate-set-field + vim.ui.select = function(...) + require("lazy").load({ plugins = { "dressing.nvim" } }) + return vim.ui.select(...) + end + ---@diagnostic disable-next-line: duplicate-set-field + vim.ui.input = function(...) + require("lazy").load({ plugins = { "dressing.nvim" } }) + return vim.ui.input(...) + end + end, + }, + + { + "neovim/nvim-lspconfig", + opts = function() + if LazyVim.pick.want() ~= "telescope" then + return + end + local Keys = require("lazyvim.plugins.lsp.keymaps").get() + -- stylua: ignore + vim.list_extend(Keys, { + { "gd", function() require("telescope.builtin").lsp_definitions({ reuse_win = true }) end, desc = "Goto Definition", has = "definition" }, + { "gr", "Telescope lsp_references", desc = "References", nowait = true }, + { "gI", function() require("telescope.builtin").lsp_implementations({ reuse_win = true }) end, desc = "Goto Implementation" }, + { "gy", function() require("telescope.builtin").lsp_type_definitions({ reuse_win = true }) end, desc = "Goto T[y]pe Definition" }, + }) + end, + }, +} diff --git a/lua/lazyvim/plugins/extras/lang/astro.lua b/lua/lazyvim/plugins/extras/lang/astro.lua index a4384148..1364902b 100644 --- a/lua/lazyvim/plugins/extras/lang/astro.lua +++ b/lua/lazyvim/plugins/extras/lang/astro.lua @@ -3,9 +3,11 @@ return { return LazyVim.extras.wants({ ft = "astro", root = { + -- https://docs.astro.build/en/guides/configuring-astro/#supported-config-file-types "astro.config.js", "astro.config.mjs", "astro.config.cjs", + "astro.config.ts", }, }) end, diff --git a/lua/lazyvim/plugins/extras/lang/elixir.lua b/lua/lazyvim/plugins/extras/lang/elixir.lua index a9956570..f391edbd 100644 --- a/lua/lazyvim/plugins/extras/lang/elixir.lua +++ b/lua/lazyvim/plugins/extras/lang/elixir.lua @@ -5,6 +5,39 @@ return { root = "mix.exs", }) end, + { + "neovim/nvim-lspconfig", + opts = { + servers = { + elixirls = { + keys = { + { + "cp", + function() + local params = vim.lsp.util.make_position_params() + LazyVim.lsp.execute({ + command = "manipulatePipes:serverid", + arguments = { "toPipe", params.textDocument.uri, params.position.line, params.position.character }, + }) + end, + desc = "To Pipe", + }, + { + "cP", + function() + local params = vim.lsp.util.make_position_params() + LazyVim.lsp.execute({ + command = "manipulatePipes:serverid", + arguments = { "fromPipe", params.textDocument.uri, params.position.line, params.position.character }, + }) + end, + desc = "From Pipe", + }, + }, + }, + }, + }, + }, { "nvim-treesitter/nvim-treesitter", opts = { ensure_installed = { "elixir", "heex", "eex" } }, @@ -25,12 +58,13 @@ return { "nvimtools/none-ls.nvim", optional = true, opts = function(_, opts) - if vim.fn.executable("credo") == 0 then - return - end local nls = require("null-ls") opts.sources = vim.list_extend(opts.sources or {}, { - nls.builtins.diagnostics.credo, + nls.builtins.diagnostics.credo.with({ + condition = function(utils) + return utils.root_has_file(".credo.exs") + end, + }), }) end, }, @@ -38,12 +72,17 @@ return { "mfussenegger/nvim-lint", optional = true, opts = function(_, opts) - if vim.fn.executable("credo") == 0 then - return - end opts.linters_by_ft = { elixir = { "credo" }, } + + opts.linters = { + credo = { + condition = function(ctx) + return vim.fs.find({ ".credo.exs" }, { path = ctx.filename, upward = true })[1] + end, + }, + } end, }, } diff --git a/lua/lazyvim/plugins/extras/lang/erlang.lua b/lua/lazyvim/plugins/extras/lang/erlang.lua new file mode 100644 index 00000000..e905fdcf --- /dev/null +++ b/lua/lazyvim/plugins/extras/lang/erlang.lua @@ -0,0 +1,20 @@ +return { + recommended = function() + return LazyVim.extras.wants({ + ft = { "erlang" }, + root = { "rebar.config", "erlang.mk" }, + }) + end, + { + "neovim/nvim-lspconfig", + opts = { + servers = { + erlangls = {}, + }, + }, + }, + { + "nvim-treesitter/nvim-treesitter", + opts = { ensure_installed = { "erlang" } }, + }, +} diff --git a/lua/lazyvim/plugins/extras/lang/go.lua b/lua/lazyvim/plugins/extras/lang/go.lua index b3e0ffab..b9544cfd 100644 --- a/lua/lazyvim/plugins/extras/lang/go.lua +++ b/lua/lazyvim/plugins/extras/lang/go.lua @@ -14,10 +14,6 @@ return { opts = { servers = { gopls = { - keys = { - -- Workaround for the lack of a DAP strategy in neotest-go: https://github.com/nvim-neotest/neotest-go/issues/12 - { "td", "lua require('dap-go').debug_test()", desc = "Debug Nearest (Go)" }, - }, settings = { gopls = { gofumpt = true, @@ -121,7 +117,7 @@ return { }, { "leoluz/nvim-dap-go", - config = true, + opts = {}, }, }, }, @@ -129,16 +125,29 @@ return { "nvim-neotest/neotest", optional = true, dependencies = { - "nvim-neotest/neotest-go", + "fredrikaverpil/neotest-golang", }, opts = { adapters = { - ["neotest-go"] = { - -- Here we can set options for neotest-go, e.g. - -- args = { "-tags=integration" } - recursive_run = true, + ["neotest-golang"] = { + -- Here we can set options for neotest-golang, e.g. + -- go_test_args = { "-v", "-race", "-count=1", "-timeout=60s" }, + dap_go_enabled = true, -- requires leoluz/nvim-dap-go }, }, }, }, + + -- Filetype icons + { + "echasnovski/mini.icons", + opts = { + file = { + [".go-version"] = { glyph = "", hl = "MiniIconsBlue" }, + }, + filetype = { + gotmpl = { glyph = "󰟓", hl = "MiniIconsGrey" }, + }, + }, + }, } diff --git a/lua/lazyvim/plugins/extras/lang/java.lua b/lua/lazyvim/plugins/extras/lang/java.lua index 86be762a..97e37ef5 100644 --- a/lua/lazyvim/plugins/extras/lang/java.lua +++ b/lua/lazyvim/plugins/extras/lang/java.lua @@ -71,6 +71,8 @@ return { dependencies = { "folke/which-key.nvim" }, ft = java_filetypes, opts = function() + local mason_registry = require("mason-registry") + local lombok_jar = mason_registry.get_package("jdtls"):get_install_path() .. "/lombok.jar" return { -- How to find the root dir for a given filename. The default comes from -- lspconfig which provides a function specifically for java projects. @@ -91,7 +93,10 @@ return { -- How to run jdtls. This can be overridden to a full java command-line -- if the Python wrapper script doesn't suffice. - cmd = { vim.fn.exepath("jdtls") }, + cmd = { + vim.fn.exepath("jdtls"), + string.format("--jvm-arg=-javaagent:%s", lombok_jar), + }, full_cmd = function(opts) local fname = vim.api.nvim_buf_get_name(0) local root_dir = opts.root_dir(fname) @@ -185,30 +190,40 @@ return { local client = vim.lsp.get_client_by_id(args.data.client_id) if client and client.name == "jdtls" then local wk = require("which-key") - wk.register({ - ["cx"] = { name = "+extract" }, - ["cxv"] = { require("jdtls").extract_variable_all, "Extract Variable" }, - ["cxc"] = { require("jdtls").extract_constant, "Extract Constant" }, - ["gs"] = { require("jdtls").super_implementation, "Goto Super" }, - ["gS"] = { require("jdtls.tests").goto_subjects, "Goto Subjects" }, - ["co"] = { require("jdtls").organize_imports, "Organize Imports" }, - }, { mode = "n", buffer = args.buf }) - wk.register({ - ["c"] = { name = "+code" }, - ["cx"] = { name = "+extract" }, - ["cxm"] = { - [[lua require('jdtls').extract_method(true)]], - "Extract Method", + wk.add({ + { + mode = "n", + buffer = args.buf, + { "cx", group = "extract" }, + { "cxv", require("jdtls").extract_variable_all, desc = "Extract Variable" }, + { "cxc", require("jdtls").extract_constant, desc = "Extract Constant" }, + { "gs", require("jdtls").super_implementation, desc = "Goto Super" }, + { "gS", require("jdtls.tests").goto_subjects, desc = "Goto Subjects" }, + { "co", require("jdtls").organize_imports, desc = "Organize Imports" }, }, - ["cxv"] = { - [[lua require('jdtls').extract_variable_all(true)]], - "Extract Variable", + }) + wk.add({ + { + mode = "v", + buffer = args.buf, + { "cx", group = "extract" }, + { + "cxm", + [[lua require('jdtls').extract_method(true)]], + desc = "Extract Method", + }, + { + "cxv", + [[lua require('jdtls').extract_variable_all(true)]], + desc = "Extract Variable", + }, + { + "cxc", + [[lua require('jdtls').extract_constant(true)]], + desc = "Extract Constant", + }, }, - ["cxc"] = { - [[lua require('jdtls').extract_constant(true)]], - "Extract Constant", - }, - }, { mode = "v", buffer = args.buf }) + }) if opts.dap and LazyVim.has("nvim-dap") and mason_registry.is_installed("java-debug-adapter") then -- custom init for Java debugger @@ -218,12 +233,32 @@ return { -- Java Test require Java debugger to work if opts.test and mason_registry.is_installed("java-test") then -- custom keymaps for Java test runner (not yet compatible with neotest) - wk.register({ - ["t"] = { name = "+test" }, - ["tt"] = { require("jdtls.dap").test_class, "Run All Test" }, - ["tr"] = { require("jdtls.dap").test_nearest_method, "Run Nearest Test" }, - ["tT"] = { require("jdtls.dap").pick_test, "Run Test" }, - }, { mode = "n", buffer = args.buf }) + wk.add({ + { + mode = "n", + buffer = args.buf, + { "t", group = "test" }, + { + "tt", + function() + require("jdtls.dap").test_class({ + config_overrides = type(opts.test) ~= "boolean" and opts.test.config_overrides or nil, + }) + end, + desc = "Run All Test", + }, + { + "tr", + function() + require("jdtls.dap").test_nearest_method({ + config_overrides = type(opts.test) ~= "boolean" and opts.test.config_overrides or nil, + }) + end, + desc = "Run Nearest Test", + }, + { "tT", require("jdtls.dap").pick_test, desc = "Run Test" }, + }, + }) end end diff --git a/lua/lazyvim/plugins/extras/lang/lean.lua b/lua/lazyvim/plugins/extras/lang/lean.lua new file mode 100644 index 00000000..9ac37f7d --- /dev/null +++ b/lua/lazyvim/plugins/extras/lang/lean.lua @@ -0,0 +1,125 @@ +return { + recommended = function() + return LazyVim.extras.wants({ + ft = { "lean" }, + root = { "lean-toolchain" }, + }) + end, + "Julian/lean.nvim", + event = { "BufReadPre *.lean", "BufNewFile *.lean" }, + dependencies = { + "nvim-lua/plenary.nvim", + }, + + -- see details below for full configuration options + opts = { + -- Enable the Lean language server(s)? + -- + -- false to disable, otherwise should be a table of options to pass to `leanls` + -- + -- See https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#leanls for details. + -- In particular ensure you have followed instructions setting up a callback + -- for `LspAttach` which sets your key bindings! + lsp = { + init_options = { + -- See Lean.Lsp.InitializationOptions for details and further options. + + -- Time (in milliseconds) which must pass since latest edit until elaboration begins. + -- Lower values may make editing feel faster at the cost of higher CPU usage. + -- Note that lean.nvim changes the Lean default for this value! + editDelay = 0, + + -- Whether to signal that widgets are supported. + hasWidgets = true, + }, + }, + + ft = { + -- A list of patterns which will be used to protect any matching + -- Lean file paths from being accidentally modified (by marking the + -- buffer as `nomodifiable`). + nomodifiable = { + -- by default, this list includes the Lean standard libraries, + -- as well as files within dependency directories (e.g. `_target`) + -- Set this to an empty table to disable. + }, + }, + + -- Abbreviation support + abbreviations = { + -- Enable expanding of unicode abbreviations? + enable = true, + -- additional abbreviations: + extra = { + -- Add a \wknight abbreviation to insert ♘ + -- + -- Note that the backslash is implied, and that you of + -- course may also use a snippet engine directly to do + -- this if so desired. + wknight = "♘", + }, + -- Change if you don't like the backslash + -- (comma is a popular choice on French keyboards) + leader = "\\", + }, + + -- Enable suggested mappings? + -- + -- false by default, true to enable + mappings = true, + + -- Infoview support + infoview = { + -- Automatically open an infoview on entering a Lean buffer? + -- Should be a function that will be called anytime a new Lean file + -- is opened. Return true to open an infoview, otherwise false. + -- Setting this to `true` is the same as `function() return true end`, + -- i.e. autoopen for any Lean file, or setting it to `false` is the + -- same as `function() return false end`, i.e. never autoopen. + autoopen = true, + + -- Set infoview windows' starting dimensions. + -- Windows are opened horizontally or vertically depending on spacing. + width = 50, + height = 20, + + -- Put the infoview on the top or bottom when horizontal? + -- top | bottom + horizontal_position = "bottom", + + -- Always open the infoview window in a separate tabpage. + -- Might be useful if you are using a screen reader and don't want too + -- many dynamic updates in the terminal at the same time. + -- Note that `height` and `width` will be ignored in this case. + separate_tab = false, + + -- Show indicators for pin locations when entering an infoview window? + -- always | never | auto (= only when there are multiple pins) + indicators = "auto", + }, + + -- Progress bar support + progress_bars = { + -- Enable the progress bars? + enable = true, + -- What character should be used for the bars? + character = "│", + -- Use a different priority for the signs + priority = 10, + }, + + -- Redirect Lean's stderr messages somehwere (to a buffer by default) + stderr = { + enable = true, + -- height of the window + height = 5, + -- a callback which will be called with (multi-line) stderr output + -- e.g., use: + -- on_lines = function(lines) vim.notify(lines) end + -- if you want to redirect stderr to `vim.notify`. + -- The default implementation will redirect to a dedicated stderr + -- window. + on_lines = nil, + }, + }, +} diff --git a/lua/lazyvim/plugins/extras/lang/markdown.lua b/lua/lazyvim/plugins/extras/lang/markdown.lua index 0b1c08a8..0934f10a 100644 --- a/lua/lazyvim/plugins/extras/lang/markdown.lua +++ b/lua/lazyvim/plugins/extras/lang/markdown.lua @@ -1,7 +1,12 @@ +LazyVim.on_very_lazy(function() + vim.filetype.add({ + extension = { mdx = "markdown.mdx" }, + }) +end) return { recommended = function() return LazyVim.extras.wants({ - ft = "markdown", + ft = { "markdown", "markdown.mdx" }, root = "README.md", }) end, @@ -9,15 +14,34 @@ return { "stevearc/conform.nvim", optional = true, opts = { + formatters = { + ["markdown-toc"] = { + condition = function(_, ctx) + for _, line in ipairs(vim.api.nvim_buf_get_lines(ctx.buf, 0, -1, false)) do + if line:find("") then + return true + end + end + end, + }, + ["markdownlint-cli2"] = { + condition = function(_, ctx) + local diag = vim.tbl_filter(function(d) + return d.source == "markdownlint" + end, vim.diagnostic.get(ctx.buf)) + return #diag > 0 + end, + }, + }, formatters_by_ft = { - ["markdown"] = { { "prettierd", "prettier" }, "markdownlint", "markdown-toc" }, - ["markdown.mdx"] = { { "prettierd", "prettier" }, "markdownlint", "markdown-toc" }, + ["markdown"] = { "prettier", "markdownlint-cli2", "markdown-toc" }, + ["markdown.mdx"] = { "prettier", "markdownlint-cli2", "markdown-toc" }, }, }, }, { "williamboman/mason.nvim", - opts = { ensure_installed = { "markdownlint", "markdown-toc" } }, + opts = { ensure_installed = { "markdownlint-cli2", "markdown-toc" } }, }, { "nvimtools/none-ls.nvim", @@ -25,7 +49,7 @@ return { opts = function(_, opts) local nls = require("null-ls") opts.sources = vim.list_extend(opts.sources or {}, { - nls.builtins.diagnostics.markdownlint, + nls.builtins.diagnostics.markdownlint_cli2, }) end, }, @@ -34,7 +58,7 @@ return { optional = true, opts = { linters_by_ft = { - markdown = { "markdownlint" }, + markdown = { "markdownlint-cli2" }, }, }, }, @@ -68,30 +92,36 @@ return { }, { - "lukas-reineke/headlines.nvim", - opts = function() - local opts = {} - for _, ft in ipairs({ "markdown", "norg", "rmd", "org" }) do - opts[ft] = { - headline_highlights = {}, - -- disable bullets for now. See https://github.com/lukas-reineke/headlines.nvim/issues/66 - bullets = {}, - } - for i = 1, 6 do - local hl = "Headline" .. i - vim.api.nvim_set_hl(0, hl, { link = "Headline", default = true }) - table.insert(opts[ft].headline_highlights, hl) - end - end - return opts - end, + "MeanderingProgrammer/markdown.nvim", + opts = { + file_types = { "markdown", "norg", "rmd", "org" }, + code = { + sign = false, + width = "block", + right_pad = 1, + }, + heading = { + sign = false, + icons = {}, + }, + }, ft = { "markdown", "norg", "rmd", "org" }, config = function(_, opts) - -- PERF: schedule to prevent headlines slowing down opening a file - vim.schedule(function() - require("headlines").setup(opts) - require("headlines").refresh() - end) + require("render-markdown").setup(opts) + LazyVim.toggle.map("um", { + name = "Render Markdown", + get = function() + return require("render-markdown.state").enabled + end, + set = function(enabled) + local m = require("render-markdown") + if enabled then + m.enable() + else + m.disable() + end + end, + }) end, }, } diff --git a/lua/lazyvim/plugins/extras/lang/ocaml.lua b/lua/lazyvim/plugins/extras/lang/ocaml.lua new file mode 100644 index 00000000..d4485856 --- /dev/null +++ b/lua/lazyvim/plugins/extras/lang/ocaml.lua @@ -0,0 +1,39 @@ +return { + recommended = function() + return LazyVim.extras.wants({ + ft = { "ml", "mli", "cmi", "cmo", "cmx", "cma", "cmxa", "cmxs", "cmt", "cmti", "opam" }, + root = { "merlin.opam", "dune-project" }, + }) + end, + { + "nvim-treesitter/nvim-treesitter", + opts = function(_, opts) + if type(opts.ensure_installed) == "table" then + vim.list_extend(opts.ensure_installed, { "ocaml" }) + end + end, + }, + { + "neovim/nvim-lspconfig", + opts = { + servers = { + ocamllsp = { + get_language_id = function(_, ftype) + return language_id_of[ftype] + end, + root_dir = function(fname) + return require("lspconfig.util").root_pattern( + "*.opam", + "esy.json", + "package.json", + ".git", + "dune-project", + "dune-workspace", + "*.ml" + )(fname) + end, + }, + }, + }, + }, +} diff --git a/lua/lazyvim/plugins/extras/lang/omnisharp.lua b/lua/lazyvim/plugins/extras/lang/omnisharp.lua index fa0dac48..cac9cf5b 100644 --- a/lua/lazyvim/plugins/extras/lang/omnisharp.lua +++ b/lua/lazyvim/plugins/extras/lang/omnisharp.lua @@ -75,6 +75,9 @@ return { type = "executable", command = vim.fn.exepath("netcoredbg"), args = { "--interpreter=vscode" }, + options = { + detached = false, + }, } end for _, lang in ipairs({ "cs", "fsharp", "vb" }) do diff --git a/lua/lazyvim/plugins/extras/lang/php.lua b/lua/lazyvim/plugins/extras/lang/php.lua index 334091bb..70814eae 100644 --- a/lua/lazyvim/plugins/extras/lang/php.lua +++ b/lua/lazyvim/plugins/extras/lang/php.lua @@ -1,3 +1,11 @@ +if lazyvim_docs then + -- LSP Server to use for PHP. + -- Set to "intelephense" to use intelephense instead of phpactor. + vim.g.lazyvim_php_lsp = "intelephense" +end + +local lsp = vim.g.lazyvim_php_lsp or "phpactor" + return { recommended = { ft = "php", @@ -13,18 +21,31 @@ return { "neovim/nvim-lspconfig", opts = { servers = { - phpactor = {}, + phpactor = { + enabled = lsp == "phpactor", + }, + intelephense = { + enabled = lsp == "intelephense", + }, + [lsp] = { + enabled = true, + }, }, }, }, + { + "williamboman/mason.nvim", + opts = { + ensure_installed = { + "phpcs", + "php-cs-fixer", + }, + }, + }, { "mfussenegger/nvim-dap", optional = true, - dependencies = { - "williamboman/mason.nvim", - opts = { ensure_installed = { "php-debug-adapter" } }, - }, opts = function() local dap = require("dap") local path = require("mason-registry").get_package("php-debug-adapter"):get_install_path() @@ -35,4 +56,32 @@ return { } end, }, + { + "nvimtools/none-ls.nvim", + optional = true, + opts = function(_, opts) + local nls = require("null-ls") + opts.sources = opts.sources or {} + table.insert(opts.sources, nls.builtins.formatting.phpcsfixer) + table.insert(opts.sources, nls.builtins.diagnostics.phpcs) + end, + }, + { + "mfussenegger/nvim-lint", + optional = true, + opts = { + linters_by_ft = { + php = { "phpcs" }, + }, + }, + }, + { + "stevearc/conform.nvim", + optional = true, + opts = { + formatters_by_ft = { + php = { "php_cs_fixer" }, + }, + }, + }, } diff --git a/lua/lazyvim/plugins/extras/lang/prisma.lua b/lua/lazyvim/plugins/extras/lang/prisma.lua new file mode 100644 index 00000000..f086d4ca --- /dev/null +++ b/lua/lazyvim/plugins/extras/lang/prisma.lua @@ -0,0 +1,21 @@ +return { + recommended = function() + return LazyVim.extras.wants({ + ft = "prisma", + }) + end, + { + "nvim-treesitter/nvim-treesitter", + opts = { + ensure_installed = { "prisma" }, + }, + }, + { + "neovim/nvim-lspconfig", + opts = { + servers = { + prismals = {}, + }, + }, + }, +} diff --git a/lua/lazyvim/plugins/extras/lang/python.lua b/lua/lazyvim/plugins/extras/lang/python.lua index 0be4b93c..f85b23be 100644 --- a/lua/lazyvim/plugins/extras/lang/python.lua +++ b/lua/lazyvim/plugins/extras/lang/python.lua @@ -2,11 +2,12 @@ if lazyvim_docs then -- LSP Server to use for Python. -- Set to "basedpyright" to use basedpyright instead of pyright. vim.g.lazyvim_python_lsp = "pyright" - vim.g.lazyvim_python_ruff = "ruff_lsp" + -- Set to "ruff_lsp" to use the old LSP implementation version. + vim.g.lazyvim_python_ruff = "ruff" end local lsp = vim.g.lazyvim_python_lsp or "pyright" -local ruff = vim.g.lazyvim_python_ruff or "ruff_lsp" +local ruff = vim.g.lazyvim_python_ruff or "ruff" return { recommended = function() @@ -30,22 +31,22 @@ return { "neovim/nvim-lspconfig", opts = { servers = { - pyright = { - enabled = lsp == "pyright", - }, - basedpyright = { - enabled = lsp == "basedpyright", - }, - [lsp] = { - enabled = true, + ruff = { + cmd_env = { RUFF_TRACE = "messages" }, + init_options = { + settings = { + logLevel = "error", + }, + }, + keys = { + { + "co", + LazyVim.lsp.action["source.organizeImports"], + desc = "Organize Imports", + }, + }, }, ruff_lsp = { - enabled = ruff == "ruff_lsp", - }, - ruff = { - enabled = ruff == "ruff", - }, - [ruff] = { keys = { { "co", @@ -65,6 +66,16 @@ return { }, }, }, + { + "neovim/nvim-lspconfig", + opts = function(_, opts) + local servers = { "pyright", "basedpyright", "ruff", "ruff_lsp", ruff, lsp } + for _, server in ipairs(servers) do + opts.servers[server] = opts.servers[server] or {} + opts.servers[server].enabled = server == lsp or server == ruff + end + end, + }, { "nvim-neotest/neotest", optional = true, @@ -92,14 +103,22 @@ return { { "dPc", function() require('dap-python').test_class() end, desc = "Debug Class", ft = "python" }, }, config = function() - require("dap-python").setup(LazyVim.get_pkg_path("debugpy", "/venv/bin/python")) + if vim.fn.has("win32") == 1 then + require("dap-python").setup(LazyVim.get_pkg_path("debugpy", "/venv/Scripts/pythonw.exe")) + else + require("dap-python").setup(LazyVim.get_pkg_path("debugpy", "/venv/bin/python")) + end end, }, }, + { "linux-cultist/venv-selector.nvim", branch = "regexp", -- Use this branch for the new version cmd = "VenvSelect", + enabled = function() + return LazyVim.has("telescope.nvim") + end, opts = { settings = { options = { @@ -111,6 +130,7 @@ return { ft = "python", keys = { { "cv", ":VenvSelect", desc = "Select VirtualEnv", ft = "python" } }, }, + { "hrsh7th/nvim-cmp", opts = function(_, opts) @@ -118,4 +138,15 @@ return { table.insert(opts.auto_brackets, "python") end, }, + + -- Don't mess up DAP adapters provided by nvim-dap-python + { + "jay-babu/mason-nvim-dap.nvim", + optional = true, + opts = { + handlers = { + python = function() end, + }, + }, + }, } diff --git a/lua/lazyvim/plugins/extras/lang/r.lua b/lua/lazyvim/plugins/extras/lang/r.lua index e3dd3302..f2c46041 100644 --- a/lua/lazyvim/plugins/extras/lang/r.lua +++ b/lua/lazyvim/plugins/extras/lang/r.lua @@ -19,24 +19,22 @@ return { vim.keymap.set("n", "", "RDSendLine", { buffer = true }) vim.keymap.set("v", "", "RSendSelection", { buffer = true }) - -- Increase the width of which-key to handle the longer r-nvim descriptions local wk = require("which-key") - -- Workaround from https://github.com/folke/which-key.nvim/issues/514#issuecomment-1987286901 - wk.register({ - [""] = { - a = { name = "+(a)ll", ["🚫"] = "which_key_ignore" }, - b = { name = "+(b)etween marks", ["🚫"] = "which_key_ignore" }, - c = { name = "+(c)hunks", ["🚫"] = "which_key_ignore" }, - f = { name = "+(f)unctions", ["🚫"] = "which_key_ignore" }, - g = { name = "+(g)oto", ["🚫"] = "which_key_ignore" }, - k = { name = "+(k)nit", ["🚫"] = "which_key_ignore" }, - p = { name = "+(p)aragraph", ["🚫"] = "which_key_ignore" }, - q = { name = "+(q)uarto", ["🚫"] = "which_key_ignore" }, - r = { name = "+(r) general", ["🚫"] = "which_key_ignore" }, - s = { name = "+(s)plit or (s)end", ["🚫"] = "which_key_ignore" }, - t = { name = "+(t)erminal", ["🚫"] = "which_key_ignore" }, - v = { name = "+(v)iew", ["🚫"] = "which_key_ignore" }, - }, + wk.add({ + buffer = true, + { "a", group = "all" }, + { "b", group = "between marks" }, + { "c", group = "chunks" }, + { "f", group = "functions" }, + { "g", group = "goto" }, + { "i", group = "install" }, + { "k", group = "knit" }, + { "p", group = "paragraph" }, + { "q", group = "quarto" }, + { "r", group = "r general" }, + { "s", group = "split or send" }, + { "t", group = "terminal" }, + { "v", group = "view" }, }) end, }, diff --git a/lua/lazyvim/plugins/extras/lang/ruby.lua b/lua/lazyvim/plugins/extras/lang/ruby.lua index c70e645d..6eb4fce5 100644 --- a/lua/lazyvim/plugins/extras/lang/ruby.lua +++ b/lua/lazyvim/plugins/extras/lang/ruby.lua @@ -1,3 +1,17 @@ +if lazyvim_docs then + -- LSP Server to use for Ruby. + -- Set to "solargraph" to use solargraph instead of ruby_lsp. + vim.g.lazyvim_ruby_lsp = "ruby_lsp" + vim.g.lazyvim_ruby_formatter = "rubocop" +end + +local lsp = vim.g.lazyvim_ruby_lsp or "ruby_lsp" +if vim.fn.has("nvim-0.10") == 0 then + -- ruby_lsp does not work well with Neovim < 0.10 + lsp = vim.g.lazyvim_ruby_lsp or "solargraph" +end +local formatter = vim.g.lazyvim_ruby_formatter or "rubocop" + return { recommended = function() return LazyVim.extras.wants({ @@ -11,12 +25,29 @@ return { }, { "neovim/nvim-lspconfig", + ---@class PluginLspOpts opts = { + ---@type lspconfig.options servers = { - solargraph = {}, + ruby_lsp = { + enabled = lsp == "ruby_lsp", + }, + solargraph = { + enabled = lsp == "solargraph", + }, + rubocop = { + enabled = formatter == "rubocop", + }, + standardrb = { + enabled = formatter == "standardrb", + }, }, }, }, + { + "williamboman/mason.nvim", + opts = { ensure_installed = { "erb-formatter", "erb-lint" } }, + }, { "mfussenegger/nvim-dap", optional = true, @@ -27,6 +58,16 @@ return { end, }, }, + { + "stevearc/conform.nvim", + optional = true, + opts = { + formatters_by_ft = { + ruby = { formatter }, + eruby = { "erb-format" }, + }, + }, + }, { "nvim-neotest/neotest", optional = true, diff --git a/lua/lazyvim/plugins/extras/lang/rust.lua b/lua/lazyvim/plugins/extras/lang/rust.lua index a24d85f9..9e8655b4 100644 --- a/lua/lazyvim/plugins/extras/lang/rust.lua +++ b/lua/lazyvim/plugins/extras/lang/rust.lua @@ -65,11 +65,7 @@ return { }, }, -- Add clippy lints for Rust. - checkOnSave = { - allFeatures = true, - command = "clippy", - extraArgs = { "--no-deps" }, - }, + checkOnSave = true, procMacro = { enable = true, ignored = { diff --git a/lua/lazyvim/plugins/extras/lang/sql.lua b/lua/lazyvim/plugins/extras/lang/sql.lua index 4f185ab1..a4b426ba 100644 --- a/lua/lazyvim/plugins/extras/lang/sql.lua +++ b/lua/lazyvim/plugins/extras/lang/sql.lua @@ -1,3 +1,31 @@ +if lazyvim_docs then + -- The setup below will automatically configure connections without the need for manual input each time. + + -- Example configuration using dictionary with keys: + -- vim.g.dbs = { + -- dev = "Replace with your database connection URL.", + -- staging = "Replace with your database connection URL.", + -- } + -- or + -- Example configuration using a list of dictionaries: + -- vim.g.dbs = { + -- { name = "dev", url = "Replace with your database connection URL." }, + -- { name = "staging", url = "Replace with your database connection URL." }, + -- } + + -- or + -- Create a `.lazy.lua` file in your project and set your connections like this: + -- ```lua + -- vim.g.dbs = {...} + -- + -- return {} + -- ``` + + -- Alternatively, you can also use other methods to inject your environment variables. + + -- Finally, please make sure to add `.lazy.lua` to your `.gitignore` file to protect your secrets. +end + local sql_ft = { "sql", "mysql", "plsql" } return { @@ -75,6 +103,7 @@ return { "folke/edgy.nvim", optional = true, opts = function(_, opts) + opts.right = opts.right or {} table.insert(opts.right, { title = "Database", ft = "dbui", @@ -85,6 +114,7 @@ return { end, }) + opts.bottom = opts.bottom or {} table.insert(opts.bottom, { title = "DB Query Result", ft = "dbout", diff --git a/lua/lazyvim/plugins/extras/lang/tailwind.lua b/lua/lazyvim/plugins/extras/lang/tailwind.lua index 17ed92ef..da6a3291 100644 --- a/lua/lazyvim/plugins/extras/lang/tailwind.lua +++ b/lua/lazyvim/plugins/extras/lang/tailwind.lua @@ -40,6 +40,17 @@ return { return not vim.tbl_contains(opts.filetypes_exclude or {}, ft) end, opts.filetypes) + -- Additional settings for Phoenix projects + opts.settings = { + tailwindCSS = { + includeLanguages = { + elixir = "html-eex", + eelixir = "html-eex", + heex = "html-eex", + }, + }, + } + -- Add additional filetypes vim.list_extend(opts.filetypes, opts.filetypes_include or {}) end, @@ -49,7 +60,7 @@ return { { "hrsh7th/nvim-cmp", dependencies = { - { "roobert/tailwindcss-colorizer-cmp.nvim", config = true }, + { "roobert/tailwindcss-colorizer-cmp.nvim", opts = {} }, }, opts = function(_, opts) -- original LazyVim kind icon formatter diff --git a/lua/lazyvim/plugins/extras/lang/terraform.lua b/lua/lazyvim/plugins/extras/lang/terraform.lua index 33c7c61c..5ab58f86 100644 --- a/lua/lazyvim/plugins/extras/lang/terraform.lua +++ b/lua/lazyvim/plugins/extras/lang/terraform.lua @@ -57,6 +57,7 @@ return { }, { "nvim-telescope/telescope.nvim", + optional = true, dependencies = { { "ANGkeith/telescope-terraform-doc.nvim", diff --git a/lua/lazyvim/plugins/extras/lang/typescript.lua b/lua/lazyvim/plugins/extras/lang/typescript.lua index 139c3086..71ec4604 100644 --- a/lua/lazyvim/plugins/extras/lang/typescript.lua +++ b/lua/lazyvim/plugins/extras/lang/typescript.lua @@ -248,4 +248,22 @@ return { end end, }, + + -- Filetype icons + { + "echasnovski/mini.icons", + opts = { + file = { + [".eslintrc.js"] = { glyph = "󰱺", hl = "MiniIconsYellow" }, + [".node-version"] = { glyph = "", hl = "MiniIconsGreen" }, + [".prettierrc"] = { glyph = "", hl = "MiniIconsPurple" }, + [".yarnrc.yml"] = { glyph = "", hl = "MiniIconsBlue" }, + ["eslint.config.js"] = { glyph = "󰱺", hl = "MiniIconsYellow" }, + ["package.json"] = { glyph = "", hl = "MiniIconsGreen" }, + ["tsconfig.json"] = { glyph = "", hl = "MiniIconsAzure" }, + ["tsconfig.build.json"] = { glyph = "", hl = "MiniIconsAzure" }, + ["yarn.lock"] = { glyph = "", hl = "MiniIconsBlue" }, + }, + }, + }, } diff --git a/lua/lazyvim/plugins/extras/lang/vue.lua b/lua/lazyvim/plugins/extras/lang/vue.lua index 45f1a9f7..088ce6a9 100644 --- a/lua/lazyvim/plugins/extras/lang/vue.lua +++ b/lua/lazyvim/plugins/extras/lang/vue.lua @@ -19,7 +19,13 @@ return { "neovim/nvim-lspconfig", opts = { servers = { - volar = {}, + volar = { + init_options = { + vue = { + hybridMode = true, + }, + }, + }, vtsls = {}, }, }, diff --git a/lua/lazyvim/plugins/extras/test/core.lua b/lua/lazyvim/plugins/extras/test/core.lua index dd7c7640..5579ee89 100644 --- a/lua/lazyvim/plugins/extras/test/core.lua +++ b/lua/lazyvim/plugins/extras/test/core.lua @@ -10,10 +10,11 @@ return { -- or a table of adapter names, mapped to adapter configs. -- The adapter will then be automatically loaded with the config. adapters = {}, - -- Example for loading neotest-go with a custom config + -- Example for loading neotest-golang with a custom config -- adapters = { - -- ["neotest-go"] = { - -- args = { "-tags=integration" }, + -- ["neotest-golang"] = { + -- go_test_args = { "-v", "-race", "-count=1", "-timeout=60s" }, + -- dap_go_enabled = true, -- }, -- }, status = { virtual_text = true }, @@ -85,6 +86,9 @@ return { local meta = getmetatable(adapter) if adapter.setup then adapter.setup(config) + elseif adapter.adapter then + adapter.adapter(config) + adapter = adapter.adapter elseif meta and meta.__call then adapter(config) else diff --git a/lua/lazyvim/plugins/extras/ui/alpha.lua b/lua/lazyvim/plugins/extras/ui/alpha.lua index 8feee188..1898bd08 100644 --- a/lua/lazyvim/plugins/extras/ui/alpha.lua +++ b/lua/lazyvim/plugins/extras/ui/alpha.lua @@ -23,11 +23,11 @@ return { dashboard.section.header.val = vim.split(logo, "\n") -- stylua: ignore dashboard.section.buttons.val = { - dashboard.button("f", " " .. " Find file", " Telescope find_files "), - dashboard.button("n", " " .. " New file", " ene startinsert "), - dashboard.button("r", " " .. " Recent files", " Telescope oldfiles "), - dashboard.button("g", " " .. " Find text", " Telescope live_grep "), - dashboard.button("c", " " .. " Config", " lua require('lazyvim.util').telescope.config_files()() "), + dashboard.button("f", " " .. " Find file", LazyVim.pick()), + dashboard.button("n", " " .. " New file", [[ ene startinsert ]]), + dashboard.button("r", " " .. " Recent files", LazyVim.pick("oldfiles")), + dashboard.button("g", " " .. " Find text", LazyVim.pick("live_grep")), + dashboard.button("c", " " .. " Config", LazyVim.pick.config_files()), dashboard.button("s", " " .. " Restore Session", [[ lua require("persistence").load() ]]), dashboard.button("x", " " .. " Lazy Extras", " LazyExtras "), dashboard.button("l", "󰒲 " .. " Lazy", " Lazy "), diff --git a/lua/lazyvim/plugins/extras/ui/edgy.lua b/lua/lazyvim/plugins/extras/ui/edgy.lua index 4ccdc5f0..f63e31ad 100644 --- a/lua/lazyvim/plugins/extras/ui/edgy.lua +++ b/lua/lazyvim/plugins/extras/ui/edgy.lua @@ -53,38 +53,11 @@ return { { title = "Neotest Output", ft = "neotest-output-panel", size = { height = 15 } }, }, left = { - { - title = "Neo-Tree", - ft = "neo-tree", - filter = function(buf) - return vim.b[buf].neo_tree_source == "filesystem" - end, - pinned = true, - open = function() - require("neo-tree.command").execute({ dir = LazyVim.root() }) - end, - size = { height = 0.5 }, - }, { title = "Neotest Summary", ft = "neotest-summary" }, - { - title = "Neo-Tree Git", - ft = "neo-tree", - filter = function(buf) - return vim.b[buf].neo_tree_source == "git_status" - end, - pinned = true, - open = "Neotree position=right git_status", - }, - { - title = "Neo-Tree Buffers", - ft = "neo-tree", - filter = function(buf) - return vim.b[buf].neo_tree_source == "buffers" - end, - pinned = true, - open = "Neotree position=top buffers", - }, - "neo-tree", + -- "neo-tree", + }, + right = { + { title = "Grug Far", ft = "grug-far", size = { width = 0.4 } }, }, keys = { -- increase width @@ -105,6 +78,31 @@ return { end, }, } + + if LazyVim.has("neo-tree.nvim") then + local pos = { + filesystem = "left", + buffers = "top", + git_status = "right", + document_symbols = "bottom", + diagnostics = "bottom", + } + local sources = LazyVim.opts("neo-tree.nvim").sources or {} + for i, v in ipairs(sources) do + table.insert(opts.left, i, { + title = "Neo-Tree " .. v:gsub("_", " "):gsub("^%l", string.upper), + ft = "neo-tree", + filter = function(buf) + return vim.b[buf].neo_tree_source == v + end, + pinned = true, + open = function() + vim.cmd(("Neotree show position=%s %s dir=%s"):format(pos[v] or "bottom", v, LazyVim.root())) + end, + }) + end + end + for _, pos in ipairs({ "top", "bottom", "left", "right" }) do opts[pos] = opts[pos] or {} table.insert(opts[pos], { @@ -157,14 +155,17 @@ return { local get = Offset.get Offset.get = function() if package.loaded.edgy then + local old_offset = get() local layout = require("edgy.config").layout local ret = { left = "", left_size = 0, right = "", right_size = 0 } for _, pos in ipairs({ "left", "right" }) do local sb = layout[pos] + local title = " Sidebar" .. string.rep(" ", sb.bounds.width - 8) if sb and #sb.wins > 0 then - local title = " Sidebar" .. string.rep(" ", sb.bounds.width - 8) - ret[pos] = "%#EdgyTitle#" .. title .. "%*" .. "%#WinSeparator#│%*" - ret[pos .. "_size"] = sb.bounds.width + ret[pos] = old_offset[pos .. "_size"] > 0 and old_offset[pos] + or pos == "left" and ("%#Bold#" .. title .. "%*" .. "%#BufferLineOffsetSeparator#│%*") + or pos == "right" and ("%#BufferLineOffsetSeparator#│%*" .. "%#Bold#" .. title .. "%*") + ret[pos .. "_size"] = old_offset[pos .. "_size"] > 0 and old_offset[pos .. "_size"] or sb.bounds.width end end ret.total_size = ret.left_size + ret.right_size diff --git a/lua/lazyvim/plugins/extras/ui/mini-animate.lua b/lua/lazyvim/plugins/extras/ui/mini-animate.lua index c1f44d6d..1136230a 100644 --- a/lua/lazyvim/plugins/extras/ui/mini-animate.lua +++ b/lua/lazyvim/plugins/extras/ui/mini-animate.lua @@ -14,6 +14,23 @@ return { end, { expr = true }) end + vim.api.nvim_create_autocmd("FileType", { + pattern = "grug-far", + callback = function() + vim.b.minianimate_disable = true + end, + }) + + LazyVim.toggle.map("ua", { + name = "Mini Animate", + get = function() + return not vim.g.minianimate_disable + end, + set = function(state) + vim.g.minianimate_disable = not state + end, + }) + local animate = require("mini.animate") return { resize = { diff --git a/lua/lazyvim/plugins/extras/ui/mini-indentscope.lua b/lua/lazyvim/plugins/extras/ui/mini-indentscope.lua index a7632145..1b8beeb6 100644 --- a/lua/lazyvim/plugins/extras/ui/mini-indentscope.lua +++ b/lua/lazyvim/plugins/extras/ui/mini-indentscope.lua @@ -14,17 +14,18 @@ return { init = function() vim.api.nvim_create_autocmd("FileType", { pattern = { - "help", "alpha", "dashboard", - "neo-tree", - "Trouble", - "trouble", + "fzf", + "help", "lazy", + "lazyterm", "mason", + "neo-tree", "notify", "toggleterm", - "lazyterm", + "Trouble", + "trouble", }, callback = function() vim.b.miniindentscope_disable = true diff --git a/lua/lazyvim/plugins/extras/ui/mini-starter.lua b/lua/lazyvim/plugins/extras/ui/mini-starter.lua index e6078d60..6407345c 100644 --- a/lua/lazyvim/plugins/extras/ui/mini-starter.lua +++ b/lua/lazyvim/plugins/extras/ui/mini-starter.lua @@ -29,15 +29,15 @@ return { evaluate_single = true, header = logo, items = { - new_section("Find file", "Telescope find_files", "Telescope"), - new_section("Recent files", "Telescope oldfiles", "Telescope"), - new_section("Grep text", "Telescope live_grep", "Telescope"), - new_section("Config", "lua require('lazyvim.util').telescope.config_files()()", "Config"), - new_section("Extras", "LazyExtras", "Config"), - new_section("Lazy", "Lazy", "Config"), - new_section("New file", "ene | startinsert", "Built-in"), - new_section("Quit", "qa", "Built-in"), - new_section("Session restore", [[lua require("persistence").load()]], "Session"), + new_section("Find file", LazyVim.pick(), "Telescope"), + new_section("New file", "ene | startinsert", "Built-in"), + new_section("Recent files", LazyVim.pick("oldfiles"), "Telescope"), + new_section("Find text", LazyVim.pick("live_grep"), "Telescope"), + new_section("Config", LazyVim.pick.config_files(), "Config"), + new_section("Restore session", [[lua require("persistence").load()]], "Session"), + new_section("Lazy Extras", "LazyExtras", "Config"), + new_section("Lazy", "Lazy", "Config"), + new_section("Quit", "qa", "Built-in"), }, content_hooks = { starter.gen_hook.adding_bullet(pad .. "░ ", false), @@ -69,7 +69,7 @@ return { local pad_footer = string.rep(" ", 8) starter.config.footer = pad_footer .. "⚡ Neovim loaded " .. stats.count .. " plugins in " .. ms .. "ms" -- INFO: based on @echasnovski's recommendation (thanks a lot!!!) - if vim.bo[ev.buf].filetype == "starter" then + if vim.bo[ev.buf].filetype == "ministarter" then pcall(starter.refresh) end end, diff --git a/lua/lazyvim/plugins/extras/ui/treesitter-context.lua b/lua/lazyvim/plugins/extras/ui/treesitter-context.lua index a1f8d5f3..019977ed 100644 --- a/lua/lazyvim/plugins/extras/ui/treesitter-context.lua +++ b/lua/lazyvim/plugins/extras/ui/treesitter-context.lua @@ -1,21 +1,22 @@ -- Show context of the current function return { "nvim-treesitter/nvim-treesitter-context", - event = "LazyFile", - opts = { mode = "cursor", max_lines = 3 }, - keys = { - { - "ut", - function() - local tsc = require("treesitter-context") - tsc.toggle() - if LazyVim.inject.get_upvalue(tsc.toggle, "enabled") then - LazyVim.info("Enabled Treesitter Context", { title = "Option" }) + event = "VeryLazy", + opts = function() + local tsc = require("treesitter-context") + + LazyVim.toggle.map("ut", { + name = "Treesitter Context", + get = tsc.enabled, + set = function(state) + if state then + tsc.enable() else - LazyVim.warn("Disabled Treesitter Context", { title = "Option" }) + tsc.disable() end end, - desc = "Toggle Treesitter Context", - }, - }, + }) + + return { mode = "cursor", max_lines = 3 } + end, } diff --git a/lua/lazyvim/plugins/extras/util/chezmoi.lua b/lua/lazyvim/plugins/extras/util/chezmoi.lua new file mode 100644 index 00000000..633f3008 --- /dev/null +++ b/lua/lazyvim/plugins/extras/util/chezmoi.lua @@ -0,0 +1,111 @@ +local pick_chezmoi = function() + if LazyVim.pick.picker.name == "telescope" then + require("telescope").extensions.chezmoi.find_files() + elseif LazyVim.pick.picker.name == "fzf" then + local fzf_lua = require("fzf-lua") + local results = require("chezmoi.commands").list() + local chezmoi = require("chezmoi.commands") + + local opts = { + fzf_opts = {}, + fzf_colors = true, + actions = { + ["default"] = function(selected) + chezmoi.edit({ + targets = { "~/" .. selected[1] }, + args = { "--watch" }, + }) + end, + }, + } + fzf_lua.fzf_exec(results, opts) + end +end + +return { + { + -- highlighting for chezmoi files template files + "alker0/chezmoi.vim", + init = function() + vim.g["chezmoi#use_tmp_buffer"] = 1 + vim.g["chezmoi#source_dir_path"] = os.getenv("HOME") .. "/.local/share/chezmoi" + end, + }, + { + "xvzc/chezmoi.nvim", + keys = { + { + "sz", + pick_chezmoi, + desc = "Chezmoi", + }, + }, + opts = { + edit = { + watch = false, + force = false, + }, + notification = { + on_open = true, + on_apply = true, + on_watch = false, + }, + telescope = { + select = { "" }, + }, + }, + init = function() + -- run chezmoi edit on file enter + vim.api.nvim_create_autocmd({ "BufRead", "BufNewFile" }, { + pattern = { os.getenv("HOME") .. "/.local/share/chezmoi/*" }, + callback = function() + vim.schedule(require("chezmoi.commands.__edit").watch) + end, + }) + end, + }, + { + "nvimdev/dashboard-nvim", + optional = true, + opts = function(_, opts) + local projects = { + action = pick_chezmoi, + desc = " Config", + icon = "", + key = "c", + } + + projects.desc = projects.desc .. string.rep(" ", 43 - #projects.desc) + projects.key_format = " %s" + + -- remove lazyvim config property + for i = #opts.config.center, 1, -1 do + if opts.config.center[i].key == "c" then + table.remove(opts.config.center, i) + end + end + + table.insert(opts.config.center, 5, projects) + end, + }, + + -- Filetype icons + { + "echasnovski/mini.icons", + opts = { + file = { + [".chezmoiignore"] = { glyph = "", hl = "MiniIconsGrey" }, + [".chezmoiremove"] = { glyph = "", hl = "MiniIconsGrey" }, + [".chezmoiroot"] = { glyph = "", hl = "MiniIconsGrey" }, + [".chezmoiversion"] = { glyph = "", hl = "MiniIconsGrey" }, + ["bash.tmpl"] = { glyph = "", hl = "MiniIconsGrey" }, + ["json.tmpl"] = { glyph = "", hl = "MiniIconsGrey" }, + ["ps1.tmpl"] = { glyph = "󰨊", hl = "MiniIconsGrey" }, + ["sh.tmpl"] = { glyph = "", hl = "MiniIconsGrey" }, + ["toml.tmpl"] = { glyph = "", hl = "MiniIconsGrey" }, + ["yaml.tmpl"] = { glyph = "", hl = "MiniIconsGrey" }, + ["zsh.tmpl"] = { glyph = "", hl = "MiniIconsGrey" }, + }, + }, + }, +} diff --git a/lua/lazyvim/plugins/extras/util/octo.lua b/lua/lazyvim/plugins/extras/util/octo.lua index cc5c47bf..a8286265 100644 --- a/lua/lazyvim/plugins/extras/util/octo.lua +++ b/lua/lazyvim/plugins/extras/util/octo.lua @@ -8,9 +8,6 @@ return { "pwntester/octo.nvim", cmd = "Octo", event = { { event = "BufReadCmd", pattern = "octo://*" } }, - init = function() - vim.treesitter.language.register("markdown", "octo") - end, opts = { enable_builtin = true, default_to_projects_v2 = true, @@ -41,6 +38,7 @@ return { { "pwntester/octo.nvim", opts = function(_, opts) + vim.treesitter.language.register("markdown", "octo") if LazyVim.has("telescope.nvim") then opts.picker = "telescope" elseif LazyVim.has("fzf-lua") then diff --git a/lua/lazyvim/plugins/extras/util/project.lua b/lua/lazyvim/plugins/extras/util/project.lua index 16e72077..77705f37 100644 --- a/lua/lazyvim/plugins/extras/util/project.lua +++ b/lua/lazyvim/plugins/extras/util/project.lua @@ -1,24 +1,115 @@ +local pick = nil + +pick = function() + if LazyVim.pick.picker.name == "telescope" then + return vim.cmd("Telescope projects") + elseif LazyVim.pick.picker.name == "fzf" then + local fzf_lua = require("fzf-lua") + local project = require("project_nvim.project") + local history = require("project_nvim.utils.history") + local results = history.get_recent_projects() + local utils = require("fzf-lua.utils") + + local function hl_validate(hl) + return not utils.is_hl_cleared(hl) and hl or nil + end + + local function ansi_from_hl(hl, s) + return utils.ansi_from_hl(hl_validate(hl), s) + end + + local opts = { + fzf_opts = { + ["--header"] = string.format( + ":: <%s> to %s | <%s> to %s | <%s> to %s | <%s> to %s | <%s> to %s", + ansi_from_hl("FzfLuaHeaderBind", "ctrl-t"), + ansi_from_hl("FzfLuaHeaderText", "tabedit"), + ansi_from_hl("FzfLuaHeaderBind", "ctrl-s"), + ansi_from_hl("FzfLuaHeaderText", "live_grep"), + ansi_from_hl("FzfLuaHeaderBind", "ctrl-r"), + ansi_from_hl("FzfLuaHeaderText", "oldfiles"), + ansi_from_hl("FzfLuaHeaderBind", "ctrl-w"), + ansi_from_hl("FzfLuaHeaderText", "change_dir"), + ansi_from_hl("FzfLuaHeaderBind", "ctrl-d"), + ansi_from_hl("FzfLuaHeaderText", "delete") + ), + }, + fzf_colors = true, + actions = { + ["default"] = { + function(selected) + fzf_lua.files({ cwd = selected[1] }) + end, + }, + ["ctrl-t"] = { + function(selected) + vim.cmd("tabedit") + fzf_lua.files({ cwd = selected[1] }) + end, + }, + ["ctrl-s"] = { + function(selected) + fzf_lua.live_grep({ cwd = selected[1] }) + end, + }, + ["ctrl-r"] = { + function(selected) + fzf_lua.oldfiles({ cwd = selected[1] }) + end, + }, + ["ctrl-w"] = { + function(selected) + local path = selected[1] + local ok = project.set_pwd(path) + if ok then + vim.api.nvim_win_close(0, false) + LazyVim.info("Change project dir to " .. path) + end + end, + }, + ["ctrl-d"] = function(selected) + local path = selected[1] + local choice = vim.fn.confirm("Delete '" .. path .. "' project? ", "&Yes\n&No") + if choice == 1 then + history.delete_project({ value = path }) + end + pick() + end, + }, + } + + fzf_lua.fzf_exec(results, opts) + end +end + return { { - "telescope.nvim", - dependencies = { - -- project management - { - "ahmedkhalf/project.nvim", - opts = { - manual_mode = true, - }, - event = "VeryLazy", - config = function(_, opts) - require("project_nvim").setup(opts) - LazyVim.on_load("telescope.nvim", function() - require("telescope").load_extension("projects") - end) - end, - keys = { - { "fp", "Telescope projects", desc = "Projects" }, - }, - }, + "ahmedkhalf/project.nvim", + opts = { + manual_mode = true, + }, + event = "VeryLazy", + config = function(_, opts) + require("project_nvim").setup(opts) + LazyVim.on_load("telescope.nvim", function() + require("telescope").load_extension("projects") + end) + end, + }, + + { + "nvim-telescope/telescope.nvim", + optional = true, + keys = { + { "fp", pick, desc = "Projects" }, + }, + }, + + { + "ibhagwan/fzf-lua", + optional = true, + keys = { + { "fp", pick, desc = "Projects" }, }, }, @@ -26,12 +117,13 @@ return { "goolord/alpha-nvim", optional = true, opts = function(_, dashboard) - local button = dashboard.button("p", " " .. " Projects", ":Telescope projects ") + local button = dashboard.button("p", " " .. " Projects", pick) button.opts.hl = "AlphaButtons" button.opts.hl_shortcut = "AlphaShortcut" table.insert(dashboard.section.buttons.val, 4, button) end, }, + { "echasnovski/mini.starter", optional = true, @@ -39,19 +131,20 @@ return { local items = { { name = "Projects", - action = "Telescope projects", + action = pick, section = string.rep(" ", 22) .. "Telescope", }, } vim.list_extend(opts.items, items) end, }, + { "nvimdev/dashboard-nvim", optional = true, opts = function(_, opts) local projects = { - action = "Telescope projects", + action = pick, desc = " Projects", icon = " ", key = "p", diff --git a/lua/lazyvim/plugins/extras/util/rest.lua b/lua/lazyvim/plugins/extras/util/rest.lua new file mode 100644 index 00000000..61092ca6 --- /dev/null +++ b/lua/lazyvim/plugins/extras/util/rest.lua @@ -0,0 +1,25 @@ +vim.filetype.add({ + extension = { + ["http"] = "http", + }, +}) +return { + { + "mistweaverco/kulala.nvim", + ft = "http", + keys = { + { "R", "", desc = "+Rest" }, + { "Rs", "lua require('kulala').run()", desc = "Send the request" }, + { "Rt", "lua require('kulala').toggle_view()", desc = "Toggle headers/body" }, + { "Rp", "lua require('kulala').jump_prev()", desc = "Jump to previous request" }, + { "Rn", "lua require('kulala').jump_next()", desc = "Jump to next request" }, + }, + opts = {}, + }, + { + "nvim-treesitter/nvim-treesitter", + opts = { + ensure_installed = { "http", "graphql" }, + }, + }, +} diff --git a/lua/lazyvim/plugins/extras/vscode.lua b/lua/lazyvim/plugins/extras/vscode.lua index 25930d1d..98a22205 100644 --- a/lua/lazyvim/plugins/extras/vscode.lua +++ b/lua/lazyvim/plugins/extras/vscode.lua @@ -30,7 +30,7 @@ end -- Add some vscode specific keymaps vim.api.nvim_create_autocmd("User", { - pattern = "LazyVimKeymaps", + pattern = "LazyVimKeymapsDefaults", callback = function() vim.keymap.set("n", "", "Find") vim.keymap.set("n", "/", [[call VSCodeNotify('workbench.action.findInFiles')]]) diff --git a/lua/lazyvim/plugins/formatting.lua b/lua/lazyvim/plugins/formatting.lua index 0935f6b3..ae32c0ef 100644 --- a/lua/lazyvim/plugins/formatting.lua +++ b/lua/lazyvim/plugins/formatting.lua @@ -1,6 +1,6 @@ local M = {} ----@param opts ConformOpts +---@param opts conform.setupOpts function M.setup(_, opts) for _, key in ipairs({ "format_on_save", "format_after_save" }) do if opts[key] then @@ -10,6 +10,10 @@ function M.setup(_, opts) opts[key] = nil end end + ---@diagnostic disable-next-line: undefined-field + if opts.format then + LazyVim.warn("**conform.nvim** `opts.format` is deprecated. Please use `opts.default_format_opts` instead.") + end require("conform").setup(opts) end @@ -37,8 +41,7 @@ return { priority = 100, primary = true, format = function(buf) - local opts = LazyVim.opts("conform.nvim") - require("conform").format(LazyVim.merge({}, opts.format, { bufnr = buf })) + require("conform").format({ bufnr = buf }) end, sources = function(buf) local ret = require("conform").list_formatters(buf) @@ -59,16 +62,14 @@ return { "Please refer to the docs at https://www.lazyvim.org/plugins/formatting", }, { title = "LazyVim" }) end - ---@class ConformOpts + ---@type conform.setupOpts local opts = { - -- LazyVim will use these options when formatting with the conform.nvim formatter - format = { + default_format_opts = { timeout_ms = 3000, async = false, -- not recommended to change quiet = false, -- not recommended to change - lsp_fallback = true, -- not recommended to change + lsp_format = "fallback", -- not recommended to change }, - ---@type table formatters_by_ft = { lua = { "stylua" }, fish = { "fish_indent" }, diff --git a/lua/lazyvim/plugins/init.lua b/lua/lazyvim/plugins/init.lua index 8c7b5fa1..4a43f115 100644 --- a/lua/lazyvim/plugins/init.lua +++ b/lua/lazyvim/plugins/init.lua @@ -12,5 +12,5 @@ require("lazyvim.config").init() return { { "folke/lazy.nvim", version = "*" }, - { "LazyVim/LazyVim", priority = 10000, lazy = false, config = true, cond = true, version = "*" }, + { "LazyVim/LazyVim", priority = 10000, lazy = false, opts = {}, cond = true, version = "*" }, } diff --git a/lua/lazyvim/plugins/linting.lua b/lua/lazyvim/plugins/linting.lua index 7b5b3be3..46cf2898 100644 --- a/lua/lazyvim/plugins/linting.lua +++ b/lua/lazyvim/plugins/linting.lua @@ -35,6 +35,7 @@ return { if type(linter) == "table" and type(lint.linters[name]) == "table" then lint.linters[name] = vim.tbl_deep_extend("force", lint.linters[name], linter) if type(linter.prepend_args) == "table" then + lint.linters[name].args = lint.linters[name].args or {} vim.list_extend(lint.linters[name].args, linter.prepend_args) end else diff --git a/lua/lazyvim/plugins/lsp/init.lua b/lua/lazyvim/plugins/lsp/init.lua index 371315ef..076344dd 100644 --- a/lua/lazyvim/plugins/lsp/init.lua +++ b/lua/lazyvim/plugins/lsp/init.lua @@ -5,11 +5,11 @@ return { event = "LazyFile", dependencies = { "mason.nvim", - "williamboman/mason-lspconfig.nvim", + { "williamboman/mason-lspconfig.nvim", config = function() end }, }, - ---@class PluginLspOpts opts = function() - return { + ---@class PluginLspOpts + local ret = { -- options for vim.diagnostic.config() ---@type vim.diagnostic.Opts diagnostics = { @@ -38,7 +38,7 @@ return { -- provide the inlay hints. inlay_hints = { enabled = true, - exclude = {}, -- filetypes for which you don't want to enable inlay hints + exclude = { "vue" }, -- filetypes for which you don't want to enable inlay hints }, -- Enable this to enable the builtin LSP code lenses on Neovim >= 0.10.0 -- Be aware that you also will need to properly configure your LSP server to @@ -114,6 +114,7 @@ return { -- ["*"] = function(server, opts) end, }, } + return ret end, ---@param opts PluginLspOpts config = function(_, opts) @@ -150,7 +151,7 @@ return { and vim.bo[buffer].buftype == "" and not vim.tbl_contains(opts.inlay_hints.exclude, vim.bo[buffer].filetype) then - LazyVim.toggle.inlay_hints(buffer, true) + vim.lsp.inlay_hint.enable(true, { bufnr = buffer }) end end) end @@ -170,7 +171,7 @@ return { if type(opts.diagnostics.virtual_text) == "table" and opts.diagnostics.virtual_text.prefix == "icons" then opts.diagnostics.virtual_text.prefix = vim.fn.has("nvim-0.10.0") == 0 and "●" or function(diagnostic) - local icons = require("lazyvim.config").icons.diagnostics + local icons = LazyVim.config.icons.diagnostics for d, icon in pairs(icons) do if diagnostic.severity == vim.diagnostic.severity[d:upper()] then return icon @@ -195,6 +196,9 @@ return { local server_opts = vim.tbl_deep_extend("force", { capabilities = vim.deepcopy(capabilities), }, servers[server] or {}) + if server_opts.enabled == false then + return + end if opts.setup[server] then if opts.setup[server](server, server_opts) then diff --git a/lua/lazyvim/plugins/lsp/keymaps.lua b/lua/lazyvim/plugins/lsp/keymaps.lua index 403c3db9..2a35dc97 100644 --- a/lua/lazyvim/plugins/lsp/keymaps.lua +++ b/lua/lazyvim/plugins/lsp/keymaps.lua @@ -14,11 +14,11 @@ function M.get() -- stylua: ignore M._keys = { { "cl", "LspInfo", desc = "Lsp Info" }, - { "gd", function() require("telescope.builtin").lsp_definitions({ reuse_win = true }) end, desc = "Goto Definition", has = "definition" }, - { "gr", "Telescope lsp_references", desc = "References", nowait = true }, + { "gd", vim.lsp.buf.definition, desc = "Goto Definition", has = "definition" }, + { "gr", vim.lsp.buf.references, desc = "References", nowait = true }, + { "gI", vim.lsp.buf.implementation, desc = "Goto Implementation" }, + { "gy", vim.lsp.buf.type_definition, desc = "Goto T[y]pe Definition" }, { "gD", vim.lsp.buf.declaration, desc = "Goto Declaration" }, - { "gI", function() require("telescope.builtin").lsp_implementations({ reuse_win = true }) end, desc = "Goto Implementation" }, - { "gy", function() require("telescope.builtin").lsp_type_definitions({ reuse_win = true }) end, desc = "Goto T[y]pe Definition" }, { "K", vim.lsp.buf.hover, desc = "Hover" }, { "gK", vim.lsp.buf.signature_help, desc = "Signature Help", has = "signatureHelp" }, { "", vim.lsp.buf.signature_help, mode = "i", desc = "Signature Help", has = "signatureHelp" }, diff --git a/lua/lazyvim/plugins/treesitter.lua b/lua/lazyvim/plugins/treesitter.lua index 2c4ee5b2..0f0c8fe8 100644 --- a/lua/lazyvim/plugins/treesitter.lua +++ b/lua/lazyvim/plugins/treesitter.lua @@ -1,4 +1,14 @@ return { + { + "folke/which-key.nvim", + opts = { + spec = { + { "", desc = "Decrement Selection", mode = "x" }, + { "", desc = "Increment Selection", mode = { "x", "n" } }, + }, + }, + }, + -- Treesitter is a new parser generator tool that we can -- use in Neovim to power faster and more accurate -- syntax highlighting. @@ -66,10 +76,10 @@ return { textobjects = { move = { enable = true, - goto_next_start = { ["]f"] = "@function.outer", ["]c"] = "@class.outer" }, - goto_next_end = { ["]F"] = "@function.outer", ["]C"] = "@class.outer" }, - goto_previous_start = { ["[f"] = "@function.outer", ["[c"] = "@class.outer" }, - goto_previous_end = { ["[F"] = "@function.outer", ["[C"] = "@class.outer" }, + goto_next_start = { ["]f"] = "@function.outer", ["]c"] = "@class.outer", ["]a"] = "@parameter.inner" }, + goto_next_end = { ["]F"] = "@function.outer", ["]C"] = "@class.outer", ["]A"] = "@parameter.inner" }, + goto_previous_start = { ["[f"] = "@function.outer", ["[c"] = "@class.outer", ["[a"] = "@parameter.inner" }, + goto_previous_end = { ["[F"] = "@function.outer", ["[C"] = "@class.outer", ["[A"] = "@parameter.inner" }, }, }, }, diff --git a/lua/lazyvim/plugins/ui.lua b/lua/lazyvim/plugins/ui.lua index e3c7aa87..14807497 100644 --- a/lua/lazyvim/plugins/ui.lua +++ b/lua/lazyvim/plugins/ui.lua @@ -34,24 +34,6 @@ return { end, }, - -- better vim.ui - { - "stevearc/dressing.nvim", - lazy = true, - init = function() - ---@diagnostic disable-next-line: duplicate-set-field - vim.ui.select = function(...) - require("lazy").load({ plugins = { "dressing.nvim" } }) - return vim.ui.select(...) - end - ---@diagnostic disable-next-line: duplicate-set-field - vim.ui.input = function(...) - require("lazy").load({ plugins = { "dressing.nvim" } }) - return vim.ui.input(...) - end - end, - }, - -- This is what powers LazyVim's fancy-looking -- tabs, which include filetype icons and close buttons. { @@ -79,7 +61,7 @@ return { diagnostics = "nvim_lsp", always_show_bufferline = false, diagnostics_indicator = function(_, _, diag) - local icons = require("lazyvim.config").icons.diagnostics + local icons = LazyVim.config.icons.diagnostics local ret = (diag.error and icons.Error .. diag.error .. " " or "") .. (diag.warning and icons.Warn .. diag.warning or "") return vim.trim(ret) @@ -130,7 +112,7 @@ return { local lualine_require = require("lualine_require") lualine_require.require = require - local icons = require("lazyvim.config").icons + local icons = LazyVim.config.icons vim.o.laststatus = vim.g.lualine_laststatus @@ -138,7 +120,7 @@ return { options = { theme = "auto", globalstatus = vim.o.laststatus == 3, - disabled_filetypes = { statusline = { "dashboard", "alpha", "starter" } }, + disabled_filetypes = { statusline = { "dashboard", "alpha", "ministarter" } }, }, sections = { lualine_a = { "mode" }, @@ -216,20 +198,22 @@ return { } -- do not add trouble symbols if aerial is enabled - if vim.g.trouble_lualine then + -- And allow it to be overriden for some buffer types (see autocmds) + if vim.g.trouble_lualine and LazyVim.has("trouble.nvim") then local trouble = require("trouble") - local symbols = trouble.statusline - and trouble.statusline({ - mode = "symbols", - groups = {}, - title = false, - filter = { range = true }, - format = "{kind_icon}{symbol.name:Normal}", - hl_group = "lualine_c_normal", - }) + local symbols = trouble.statusline({ + mode = "symbols", + groups = {}, + title = false, + filter = { range = true }, + format = "{kind_icon}{symbol.name:Normal}", + hl_group = "lualine_c_normal", + }) table.insert(opts.sections.lualine_c, { symbols and symbols.get, - cond = symbols and symbols.has, + cond = function() + return vim.b.trouble_lualine ~= false and symbols.has() + end, }) end @@ -241,28 +225,40 @@ return { { "lukas-reineke/indent-blankline.nvim", event = "LazyFile", - opts = { - indent = { - char = "│", - tab_char = "│", - }, - scope = { show_start = false, show_end = false }, - exclude = { - filetypes = { - "help", - "alpha", - "dashboard", - "neo-tree", - "Trouble", - "trouble", - "lazy", - "mason", - "notify", - "toggleterm", - "lazyterm", + opts = function() + LazyVim.toggle.map("ug", { + name = "Indention Guides", + get = function() + return require("ibl.config").get_config(0).enabled + end, + set = function(state) + require("ibl").setup_buffer(0, { enabled = state }) + end, + }) + + return { + indent = { + char = "│", + tab_char = "│", }, - }, - }, + scope = { show_start = false, show_end = false }, + exclude = { + filetypes = { + "help", + "alpha", + "dashboard", + "neo-tree", + "Trouble", + "trouble", + "lazy", + "mason", + "notify", + "toggleterm", + "lazyterm", + }, + }, + } + end, main = "ibl", }, @@ -305,14 +301,41 @@ return { { "snh", function() require("noice").cmd("history") end, desc = "Noice History" }, { "sna", function() require("noice").cmd("all") end, desc = "Noice All" }, { "snd", function() require("noice").cmd("dismiss") end, desc = "Dismiss All" }, - { "snt", function() require("noice").cmd("telescope") end, desc = "Noice Telescope" }, + { "snt", function() require("noice").cmd("pick") end, desc = "Noice Picker (Telescope/FzfLua)" }, { "", function() if not require("noice.lsp").scroll(4) then return "" end end, silent = true, expr = true, desc = "Scroll Forward", mode = {"i", "n", "s"} }, { "", function() if not require("noice.lsp").scroll(-4) then return "" end end, silent = true, expr = true, desc = "Scroll Backward", mode = {"i", "n", "s"}}, }, + config = function(_, opts) + -- HACK: noice shows messages from before it was enabled, + -- but this is not ideal when Lazy is installing plugins, + -- so clear the messages in this case. + if vim.o.filetype == "lazy" then + vim.cmd([[messages clear]]) + end + require("noice").setup(opts) + end, }, -- icons - { "nvim-tree/nvim-web-devicons", lazy = true }, + { + "echasnovski/mini.icons", + lazy = true, + opts = { + file = { + [".keep"] = { glyph = "󰊢", hl = "MiniIconsGrey" }, + ["devcontainer.json"] = { glyph = "", hl = "MiniIconsAzure" }, + }, + filetype = { + dotenv = { glyph = "", hl = "MiniIconsYellow" }, + }, + }, + init = function() + package.preload["nvim-web-devicons"] = function() + require("mini.icons").mock_nvim_web_devicons() + return package.loaded["nvim-web-devicons"] + end + end, + }, -- ui components { "MunifTanjim/nui.nvim", lazy = true }, @@ -343,11 +366,11 @@ return { header = vim.split(logo, "\n"), -- stylua: ignore center = { - { action = LazyVim.telescope("files"), desc = " Find File", icon = " ", key = "f" }, + { action = 'lua LazyVim.pick()()', desc = " Find File", icon = " ", key = "f" }, { action = "ene | startinsert", desc = " New File", icon = " ", key = "n" }, - { action = "Telescope oldfiles", desc = " Recent Files", icon = " ", key = "r" }, - { action = "Telescope live_grep", desc = " Find Text", icon = " ", key = "g" }, - { action = [[lua LazyVim.telescope.config_files()()]], desc = " Config", icon = " ", key = "c" }, + { action = 'lua LazyVim.pick("oldfiles")()', desc = " Recent Files", icon = " ", key = "r" }, + { action = 'lua LazyVim.pick("live_grep")()', desc = " Find Text", icon = " ", key = "g" }, + { action = 'lua LazyVim.pick.config_files()()', desc = " Config", icon = " ", key = "c" }, { action = 'lua require("persistence").load()', desc = " Restore Session", icon = " ", key = "s" }, { action = "LazyExtras", desc = " Lazy Extras", icon = " ", key = "x" }, { action = "Lazy", desc = " Lazy", icon = "󰒲 ", key = "l" }, @@ -366,13 +389,15 @@ return { button.key_format = " %s" end - -- close Lazy and re-open when the dashboard is ready + -- open dashboard after closing lazy if vim.o.filetype == "lazy" then - vim.cmd.close() - vim.api.nvim_create_autocmd("User", { - pattern = "DashboardLoaded", + vim.api.nvim_create_autocmd("WinClosed", { + pattern = tostring(vim.api.nvim_get_current_win()), + once = true, callback = function() - require("lazy").show() + vim.schedule(function() + vim.api.nvim_exec_autocmds("UIEnter", { group = "dashboard" }) + end) end, }) end diff --git a/lua/lazyvim/plugins/util.lua b/lua/lazyvim/plugins/util.lua index cf5d9e03..16706c51 100644 --- a/lua/lazyvim/plugins/util.lua +++ b/lua/lazyvim/plugins/util.lua @@ -6,7 +6,7 @@ return { { "folke/persistence.nvim", event = "BufReadPre", - opts = { options = vim.opt.sessionoptions:get() }, + opts = {}, -- stylua: ignore keys = { { "qs", function() require("persistence").load() end, desc = "Restore Session" }, diff --git a/lua/lazyvim/plugins/xtras.lua b/lua/lazyvim/plugins/xtras.lua index e636c255..761569c5 100644 --- a/lua/lazyvim/plugins/xtras.lua +++ b/lua/lazyvim/plugins/xtras.lua @@ -1,5 +1,3 @@ -local Config = require("lazyvim.config") - -- Some extras need to be loaded before others local prios = { ["lazyvim.plugins.extras.test.core"] = 1, @@ -13,15 +11,16 @@ local prios = { } ---@type string[] -local extras = LazyVim.dedup(Config.json.data.extras) +local extras = LazyVim.dedup(LazyVim.config.json.data.extras) local version = vim.version() local v = version.major .. "_" .. version.minor local compat = { "0_9" } +LazyVim.plugin.save_core() if vim.tbl_contains(compat, v) then - extras[#extras + 1] = "lazyvim.plugins.compat.nvim-" .. v + table.insert(extras, 1, "lazyvim.plugins.compat.nvim-" .. v) end table.sort(extras, function(a, b) diff --git a/lua/lazyvim/util/cmp.lua b/lua/lazyvim/util/cmp.lua index e4a7f700..8cb3d1bc 100644 --- a/lua/lazyvim/util/cmp.lua +++ b/lua/lazyvim/util/cmp.lua @@ -70,6 +70,12 @@ function M.add_missing_snippet_docs(window) end end +function M.visible() + ---@module 'cmp' + local cmp = package.loaded["cmp"] + return cmp and cmp.core.view:visible() +end + -- This is a better implementation of `cmp.confirm`: -- * check if the completion menu is visible without waiting for running sources -- * create an undo point before confirming @@ -123,4 +129,31 @@ function M.expand(snippet) end end +---@param opts cmp.ConfigSchema | {auto_brackets?: string[]} +function M.setup(opts) + for _, source in ipairs(opts.sources) do + source.group_index = source.group_index or 1 + end + + local parse = require("cmp.utils.snippet").parse + require("cmp.utils.snippet").parse = function(input) + local ok, ret = pcall(parse, input) + if ok then + return ret + end + return LazyVim.cmp.snippet_preview(input) + end + + local cmp = require("cmp") + cmp.setup(opts) + cmp.event:on("confirm_done", function(event) + if vim.tbl_contains(opts.auto_brackets or {}, vim.bo.filetype) then + LazyVim.cmp.auto_brackets(event.entry) + end + end) + cmp.event:on("menu_opened", function(event) + LazyVim.cmp.add_missing_snippet_docs(event.window) + end) +end + return M diff --git a/lua/lazyvim/util/extras.lua b/lua/lazyvim/util/extras.lua index afa0ae2f..bd5ca4f3 100644 --- a/lua/lazyvim/util/extras.lua +++ b/lua/lazyvim/util/extras.lua @@ -1,4 +1,3 @@ -local Config = require("lazyvim.config") local Float = require("lazy.view.float") local LazyConfig = require("lazy.core.config") local Plugin = require("lazy.core.plugin") @@ -85,13 +84,13 @@ end ---@param source LazyExtraSource function M.get_extra(source, modname) local enabled = vim.tbl_contains(M.state, modname) - local spec = Plugin.Spec.new(nil, { optional = true }) + local spec = Plugin.Spec.new(nil, { optional = true, pkg = false }) spec:parse({ import = modname }) local imports = vim.tbl_filter(function(x) return x ~= modname end, spec.modules) if #imports > 0 then - spec = Plugin.Spec.new(nil, { optional = true }) + spec = Plugin.Spec.new(nil, { optional = true, pkg = false }) spec.modules = vim.deepcopy(imports) spec:parse({ import = modname }) end @@ -124,7 +123,7 @@ function M.get_extra(source, modname) imports = imports, desc = require(modname).desc, recommended = recommended, - managed = vim.tbl_contains(Config.json.data.extras, modname) or not enabled, + managed = vim.tbl_contains(LazyVim.config.json.data.extras, modname) or not enabled, plugins = plugins, optional = optional, } @@ -169,17 +168,17 @@ function X:toggle() return end extra.enabled = not extra.enabled - Config.json.data.extras = vim.tbl_filter(function(name) + LazyVim.config.json.data.extras = vim.tbl_filter(function(name) return name ~= extra.module - end, Config.json.data.extras) + end, LazyVim.config.json.data.extras) M.state = vim.tbl_filter(function(name) return name ~= extra.module end, M.state) if extra.enabled then - table.insert(Config.json.data.extras, extra.module) + table.insert(LazyVim.config.json.data.extras, extra.module) M.state[#M.state + 1] = extra.module end - table.sort(Config.json.data.extras) + table.sort(LazyVim.config.json.data.extras) LazyVim.json.save() LazyVim.info( "`" @@ -250,10 +249,30 @@ end ---@param extra LazyExtra function X:extra(extra) if not extra.managed then - self:diagnostic({ - message = "Not managed by LazyExtras (config)", - severity = vim.diagnostic.severity.WARN, - }) + ---@type LazyExtra[] + local parents = {} + for _, x in ipairs(self.extras) do + if x.enabled and vim.tbl_contains(x.imports, extra.module) then + parents[#parents + 1] = x + end + end + if #parents > 0 then + local pp = vim.tbl_map(function(x) + return x.name + end, parents) + self:diagnostic({ + message = "Required by " .. table.concat(pp, ", "), + }) + elseif vim.tbl_contains(LazyVim.plugin.core_imports, extra.module) then + self:diagnostic({ + message = "This extra is included by default", + }) + else + self:diagnostic({ + message = "Not managed by LazyExtras (config)", + severity = vim.diagnostic.severity.WARN, + }) + end end extra.row = self.text:row() local hl = extra.managed and "LazySpecial" or "LazyLocal" diff --git a/lua/lazyvim/util/format.lua b/lua/lazyvim/util/format.lua index e6325538..de6ad052 100644 --- a/lua/lazyvim/util/format.lua +++ b/lua/lazyvim/util/format.lua @@ -97,10 +97,19 @@ end ---@param buf? boolean function M.toggle(buf) + M.enable(not M.enabled(), buf) +end + +---@param enable? boolean +---@param buf? boolean +function M.enable(enable, buf) + if enable == nil then + enable = true + end if buf then - vim.b.autoformat = not M.enabled() + vim.b.autoformat = enable else - vim.g.autoformat = not M.enabled() + vim.g.autoformat = enable vim.b.autoformat = nil end M.info() diff --git a/lua/lazyvim/util/init.lua b/lua/lazyvim/util/init.lua index d8f485ed..106cbdc0 100644 --- a/lua/lazyvim/util/init.lua +++ b/lua/lazyvim/util/init.lua @@ -5,7 +5,6 @@ local LazyUtil = require("lazy.core.util") ---@field ui lazyvim.util.ui ---@field lsp lazyvim.util.lsp ---@field root lazyvim.util.root ----@field telescope lazyvim.util.telescope ---@field terminal lazyvim.util.terminal ---@field lazygit lazyvim.util.lazygit ---@field toggle lazyvim.util.toggle @@ -17,6 +16,7 @@ local LazyUtil = require("lazy.core.util") ---@field json lazyvim.util.json ---@field lualine lazyvim.util.lualine ---@field mini lazyvim.util.mini +---@field pick lazyvim.util.pick ---@field cmp lazyvim.util.cmp local M = {} @@ -31,6 +31,7 @@ local deprecated = { toggle_diagnostics = { "toggle", "diagnostics" }, toggle_number = { "toggle", "number" }, fg = "ui", + telescope = "pick", } setmetatable(M, { @@ -77,8 +78,10 @@ end ---@param extra string function M.has_extra(extra) + local Config = require("lazyvim.config") local modname = "lazyvim.plugins.extras." .. extra return vim.tbl_contains(require("lazy.core.config").spec.modules, modname) + or vim.tbl_contains(Config.json.data.extras, modname) end ---@param fn fun() @@ -114,7 +117,7 @@ end ---@param name string function M.opts(name) - local plugin = require("lazy.core.config").spec.plugins[name] + local plugin = M.get_plugin(name) if not plugin then return {} end @@ -268,17 +271,19 @@ for _, level in ipairs({ "info", "warn", "error" }) do end end -local cache = {} ---@type table +local cache = {} ---@type table<(fun()), table> ---@generic T: fun() ---@param fn T ---@return T function M.memoize(fn) return function(...) local key = vim.inspect({ ... }) - if cache[key] == nil then - cache[key] = fn(...) + cache[fn] = cache[fn] or {} + if cache[fn][key] == nil then + cache[fn][key] = fn(...) end - return cache[key] + return cache[fn][key] end end + return M diff --git a/lua/lazyvim/util/json.lua b/lua/lazyvim/util/json.lua index 60466a45..a823606a 100644 --- a/lua/lazyvim/util/json.lua +++ b/lua/lazyvim/util/json.lua @@ -1,5 +1,3 @@ -local Config = require("lazyvim.config") - ---@class lazyvim.util.json local M = {} @@ -46,18 +44,17 @@ function M.encode(value) end function M.save() - Config.json.data.version = Config.json.version - local path = vim.fn.stdpath("config") .. "/lazyvim.json" - local f = io.open(path, "w") + LazyVim.config.json.data.version = LazyVim.config.json.version + local f = io.open(LazyVim.config.json.path, "w") if f then - f:write(LazyVim.json.encode(Config.json.data)) + f:write(LazyVim.json.encode(LazyVim.config.json.data)) f:close() end end function M.migrate() - LazyVim.info("Migrating `lazyvim.json` to version `" .. Config.json.version .. "`") - local json = Config.json + LazyVim.info("Migrating `lazyvim.json` to version `" .. LazyVim.config.json.version .. "`") + local json = LazyVim.config.json -- v0 if not json.data.version then diff --git a/lua/lazyvim/util/lazygit.lua b/lua/lazyvim/util/lazygit.lua index 1786eefd..2532ad08 100644 --- a/lua/lazyvim/util/lazygit.lua +++ b/lua/lazyvim/util/lazygit.lua @@ -154,25 +154,58 @@ function M.blame_line(opts) local cursor = vim.api.nvim_win_get_cursor(0) local line = cursor[1] local file = vim.api.nvim_buf_get_name(0) - local root = LazyVim.root.detectors.pattern(0, { ".git" })[1] + local root = LazyVim.root.detectors.pattern(0, { ".git" })[1] or "." local cmd = { "git", "-C", root, "log", "-n", opts.count, "-u", "-L", line .. ",+1:" .. file } return require("lazy.util").float_cmd(cmd, opts) end +-- stylua: ignore +M.remote_patterns = { + { "^(https?://.*)%.git$" , "%1" }, + { "^git@(.+):(.+)%.git$" , "https://%1/%2" }, + { "^git@(.+):(.+)$" , "https://%1/%2" }, + { "^git@(.+)/(.+)$" , "https://%1/%2" }, + { "^ssh://git@(.*)$" , "https://%1" }, + { "ssh%.dev%.azure%.com/v3/(.*)/(.*)$", "dev.azure.com/%1/_git/%2" }, + { "^https://%w*@(.*)" , "https://%1" }, + { "^git@(.*)" , "https://%1" }, + { ":%d+" , "" }, + { "%.git$" , "" }, +} + +---@param remote string +function M.get_url(remote) + local ret = remote + for _, pattern in ipairs(M.remote_patterns) do + ret = ret:gsub(pattern[1], pattern[2]) + end + return ret:find("https://") == 1 and ret or ("https://%s"):format(ret) +end + function M.browse() - local config = require("lazy.manage.git").get_config(LazyVim.root.detectors.pattern(0, { ".git" })[1]) + local lines = require("lazy.manage.process").exec({ "git", "remote", "-v" }) local remotes = {} ---@type {name:string, url:string}[] - for name, url in pairs(config) do - name = name:match("^remote%.(.-)%.url$") - if name then - url = url:gsub("git@github.com:", "https://github.com/"):gsub("%.git$", "") --[[@as string]] - table.insert(remotes, { name = name, url = url }) + + for _, line in ipairs(lines) do + local name, remote = line:match("(%S+)%s+(%S+)%s+%(fetch%)") + if name and remote then + local url = M.get_url(remote) + if url then + table.insert(remotes, { + name = name, + url = url, + }) + end end end local function open(remote) if remote then LazyVim.info(("Opening [%s](%s)"):format(remote.name, remote.url)) + if vim.fn.has("nvim-0.10") == 0 then + require("lazy.util").open(remote.url, { system = true }) + return + end vim.ui.open(remote.url) end end diff --git a/lua/lazyvim/util/lsp.lua b/lua/lazyvim/util/lsp.lua index 11877f1b..59c35314 100644 --- a/lua/lazyvim/util/lsp.lua +++ b/lua/lazyvim/util/lsp.lua @@ -129,6 +129,7 @@ function M.rename_file() vim.ui.input({ prompt = "New File Name: ", default = extra, + completion = "file", }, function(new) if not new or new == "" or new == extra then return @@ -279,10 +280,11 @@ function M.words.setup(opts) if not require("lazyvim.plugins.lsp.keymaps").has(buf, "documentHighlight") then return false end + if not ({ M.words.get() })[2] then if ev.event:find("CursorMoved") then vim.lsp.buf.clear_references() - else + elseif not LazyVim.cmp.visible() then vim.lsp.buf.document_highlight() end end diff --git a/lua/lazyvim/util/lualine.lua b/lua/lazyvim/util/lualine.lua index 3e546873..6284504a 100644 --- a/lua/lazyvim/util/lualine.lua +++ b/lua/lazyvim/util/lualine.lua @@ -30,7 +30,7 @@ function M.cmp_source(name, icon) return { function() - return icon or require("lazyvim.config").icons.kinds[name:sub(1, 1):upper() .. name:sub(2)] + return icon or LazyVim.config.icons.kinds[name:sub(1, 1):upper() .. name:sub(2)] end, cond = function() return status() ~= nil @@ -72,7 +72,7 @@ function M.format(component, text, hl_group) return component:format_hl(lualine_hl_group) .. text .. component:get_default_hl() end ----@param opts? {relative: "cwd"|"root", modified_hl: string?, directory_hl: string?, filename_hl: string?} +---@param opts? {relative: "cwd"|"root", modified_hl: string?, directory_hl: string?, filename_hl: string?, modified_sign: string?, readonly_icon: string?, length: number?} function M.pretty_path(opts) opts = vim.tbl_extend("force", { relative = "cwd", @@ -80,6 +80,7 @@ function M.pretty_path(opts) directory_hl = "", filename_hl = "Bold", modified_sign = "", + readonly_icon = " 󰌾 ", length = 3, }, opts or {}) @@ -120,7 +121,12 @@ function M.pretty_path(opts) dir = table.concat({ unpack(parts, 1, #parts - 1) }, sep) dir = M.format(self, dir .. sep, opts.directory_hl) end - return dir .. parts[#parts] + + local readonly = "" + if vim.bo.readonly then + readonly = M.format(self, opts.readonly_icon, opts.modified_hl) + end + return dir .. parts[#parts] .. readonly end end diff --git a/lua/lazyvim/util/mini.lua b/lua/lazyvim/util/mini.lua index 986a1887..e7320a73 100644 --- a/lua/lazyvim/util/mini.lua +++ b/lua/lazyvim/util/mini.lua @@ -60,53 +60,111 @@ function M.ai_buffer(ai_type) end -- register all text objects with which-key -function M.ai_whichkey() - ---@type table - local i = { - [" "] = "Whitespace", - ['"'] = 'Balanced "', - ["'"] = "Balanced '", - ["`"] = "Balanced `", - ["("] = "Balanced (", - [")"] = "Balanced ) including white-space", - [">"] = "Balanced > including white-space", - [""] = "Balanced <", - ["]"] = "Balanced ] including white-space", - ["["] = "Balanced [", - ["}"] = "Balanced } including white-space", - ["{"] = "Balanced {", - ["?"] = "User Prompt", - _ = "Underscore", - a = "Argument", - b = "Balanced ), ], }", - c = "Class", - d = "Digit(s)", - e = "Word in CamelCase & snake_case", - f = "Function", - g = "Entire file", - i = "Indent", - o = "Block, conditional, loop", - q = "Quote `, \", '", - t = "Tag", - u = "Use/call function & method", - U = "Use/call without dot in name", +---@param opts table +function M.ai_whichkey(opts) + local objects = { + { " ", desc = "whitespace" }, + { '"', desc = '" string' }, + { "'", desc = "' string" }, + { "(", desc = "() block" }, + { ")", desc = "() block with ws" }, + { "<", desc = "<> block" }, + { ">", desc = "<> block with ws" }, + { "?", desc = "user prompt" }, + { "U", desc = "use/call without dot" }, + { "[", desc = "[] block" }, + { "]", desc = "[] block with ws" }, + { "_", desc = "underscore" }, + { "`", desc = "` string" }, + { "a", desc = "argument" }, + { "b", desc = ")]} block" }, + { "c", desc = "class" }, + { "d", desc = "digit(s)" }, + { "e", desc = "CamelCase / snake_case" }, + { "f", desc = "function" }, + { "g", desc = "entire file" }, + { "i", desc = "indent" }, + { "o", desc = "block, conditional, loop" }, + { "q", desc = "quote `\"'" }, + { "t", desc = "tag" }, + { "u", desc = "use/call" }, + { "{", desc = "{} block" }, + { "}", desc = "{} with ws" }, } - local a = vim.deepcopy(i) - for k, v in pairs(a) do - a[k] = v:gsub(" including.*", "") - end - local ic = vim.deepcopy(i) - local ac = vim.deepcopy(a) - for key, name in pairs({ n = "Next", l = "Last" }) do - i[key] = vim.tbl_extend("force", { name = "Inside " .. name .. " textobject" }, ic) - a[key] = vim.tbl_extend("force", { name = "Around " .. name .. " textobject" }, ac) + local ret = { mode = { "o", "x" } } + ---@type table + local mappings = vim.tbl_extend("force", {}, { + around = "a", + inside = "i", + around_next = "an", + inside_next = "in", + around_last = "al", + inside_last = "il", + }, opts.mappings or {}) + mappings.goto_left = nil + mappings.goto_right = nil + + for name, prefix in pairs(mappings) do + name = name:gsub("^around_", ""):gsub("^inside_", "") + ret[#ret + 1] = { prefix, group = name } + for _, obj in ipairs(objects) do + local desc = obj.desc + if prefix:sub(1, 1) == "i" then + desc = desc:gsub(" with ws", "") + end + ret[#ret + 1] = { prefix .. obj[1], desc = obj.desc } + end end - require("which-key").register({ - mode = { "o", "x" }, - i = i, - a = a, + require("which-key").add(ret, { notify = false }) +end + +---@param opts {skip_next: string, skip_ts: string[], skip_unbalanced: boolean, markdown: boolean} +function M.pairs(opts) + LazyVim.toggle.map("up", { + name = "Mini Pairs", + get = function() + return not vim.g.minipairs_disable + end, + set = function(state) + vim.g.minipairs_disable = not state + end, }) + local pairs = require("mini.pairs") + pairs.setup(opts) + local open = pairs.open + pairs.open = function(pair, neigh_pattern) + if vim.fn.getcmdline() ~= "" then + return open(pair, neigh_pattern) + end + local o, c = pair:sub(1, 1), pair:sub(2, 2) + local line = vim.api.nvim_get_current_line() + local cursor = vim.api.nvim_win_get_cursor(0) + local next = line:sub(cursor[2] + 1, cursor[2] + 1) + local before = line:sub(1, cursor[2]) + if opts.markdown and o == "`" and vim.bo.filetype == "markdown" and before:match("^%s*``") then + return "`\n```" .. vim.api.nvim_replace_termcodes("", true, true, true) + end + if opts.skip_next and next ~= "" and next:match(opts.skip_next) then + return o + end + if opts.skip_ts and #opts.skip_ts > 0 then + local ok, captures = pcall(vim.treesitter.get_captures_at_pos, 0, cursor[1] - 1, math.max(cursor[2] - 1, 0)) + for _, capture in ipairs(ok and captures or {}) do + if vim.tbl_contains(opts.skip_ts, capture.capture) then + return o + end + end + end + if opts.skip_unbalanced and next == c and c ~= o then + local _, count_open = line:gsub(vim.pesc(pair:sub(1, 1)), "") + local _, count_close = line:gsub(vim.pesc(pair:sub(2, 2)), "") + if count_close > count_open then + return o + end + end + return open(pair, neigh_pattern) + end end return M diff --git a/lua/lazyvim/util/news.lua b/lua/lazyvim/util/news.lua index 5434649a..5fb4a08c 100644 --- a/lua/lazyvim/util/news.lua +++ b/lua/lazyvim/util/news.lua @@ -1,5 +1,3 @@ -local Config = require("lazyvim.config") - ---@class lazyvim.util.news local M = {} @@ -13,13 +11,13 @@ end function M.setup() vim.schedule(function() - if Config.news.lazyvim then - if not Config.json.data.news["NEWS.md"] then + if LazyVim.config.news.lazyvim then + if not LazyVim.config.json.data.news["NEWS.md"] then M.welcome() end M.lazyvim(true) end - if Config.news.neovim then + if LazyVim.config.news.neovim then M.neovim(true) end end) @@ -61,12 +59,12 @@ function M.open(file, opts) end if opts.when_changed then - local is_new = not Config.json.data.news[ref] + local is_new = not LazyVim.config.json.data.news[ref] local hash = M.hash(file) - if hash == Config.json.data.news[ref] then + if hash == LazyVim.config.json.data.news[ref] then return end - Config.json.data.news[ref] = hash + LazyVim.config.json.data.news[ref] = hash LazyVim.json.save() -- don't open if file has never been opened if is_new then @@ -83,7 +81,11 @@ function M.open(file, opts) vim.opt_local.signcolumn = "yes" vim.opt_local.statuscolumn = " " vim.opt_local.conceallevel = 3 - vim.diagnostic.disable(float.buf) + if vim.diagnostic.enable then + pcall(vim.diagnostic.enable, false, { bufnr = float.buf }) + else + pcall(vim.diagnostic.disable, float.buf) + end end return M diff --git a/lua/lazyvim/util/pick.lua b/lua/lazyvim/util/pick.lua new file mode 100644 index 00000000..7ab2b482 --- /dev/null +++ b/lua/lazyvim/util/pick.lua @@ -0,0 +1,91 @@ +---@class lazyvim.util.pick +---@overload fun(command:string, opts?:lazyvim.util.pick.Opts): fun() +local M = setmetatable({}, { + __call = function(m, ...) + return m.wrap(...) + end, +}) + +---@class lazyvim.util.pick.Opts: table +---@field root? boolean +---@field cwd? string +---@field buf? number +---@field show_untracked? boolean + +---@class LazyPicker +---@field name string +---@field open fun(command:string, opts?:lazyvim.util.pick.Opts) +---@field commands table + +---@type LazyPicker? +M.picker = nil + +---@param picker LazyPicker +function M.register(picker) + -- this only happens when using :LazyExtras + -- so allow to get the full spec + if vim.v.vim_did_enter == 1 then + return true + end + + if M.picker and M.picker.name ~= M.want() then + M.picker = nil + end + + if M.picker and M.picker.name ~= picker.name then + LazyVim.warn( + "`LazyVim.pick`: picker already set to `" .. M.picker.name .. "`,\nignoring new picker `" .. picker.name .. "`" + ) + return false + end + M.picker = picker + return true +end + +function M.want() + vim.g.lazyvim_picker = vim.g.lazyvim_picker or "auto" + if vim.g.lazyvim_picker == "auto" then + return LazyVim.has_extra("editor.fzf") and "fzf" or "telescope" + end + return vim.g.lazyvim_picker +end + +---@param command? string +---@param opts? lazyvim.util.pick.Opts +function M.open(command, opts) + if not M.picker then + return LazyVim.error("LazyVim.pick: picker not set") + end + + command = command ~= "auto" and command or "files" + opts = opts or {} + + opts = vim.deepcopy(opts) + + if type(opts.cwd) == "boolean" then + LazyVim.warn("LazyVim.pick: opts.cwd should be a string or nil") + opts.cwd = nil + end + + if not opts.cwd and opts.root ~= false then + opts.cwd = LazyVim.root({ buf = opts.buf }) + end + + command = M.picker.commands[command] or command + M.picker.open(command, opts) +end + +---@param command? string +---@param opts? lazyvim.util.pick.Opts +function M.wrap(command, opts) + opts = opts or {} + return function() + LazyVim.pick.open(command, vim.deepcopy(opts)) + end +end + +function M.config_files() + return M.wrap("files", { cwd = vim.fn.stdpath("config") }) +end + +return M diff --git a/lua/lazyvim/util/plugin.lua b/lua/lazyvim/util/plugin.lua index f34527ac..1520bdce 100644 --- a/lua/lazyvim/util/plugin.lua +++ b/lua/lazyvim/util/plugin.lua @@ -3,6 +3,9 @@ local Plugin = require("lazy.core.plugin") ---@class lazyvim.util.plugin local M = {} +---@type string[] +M.core_imports = {} + M.lazy_file_events = { "BufReadPost", "BufNewFile", "BufWritePre" } ---@type table @@ -32,6 +35,13 @@ M.renames = { ["glepnir/dashboard-nvim"] = "nvimdev/dashboard-nvim", } +function M.save_core() + if vim.v.vim_did_enter == 1 then + return + end + M.core_imports = vim.deepcopy(require("lazy.core.config").spec.modules) +end + function M.setup() M.fix_imports() M.fix_renames() diff --git a/lua/lazyvim/util/root.lua b/lua/lazyvim/util/root.lua index 4523f3cf..fc81e92f 100644 --- a/lua/lazyvim/util/root.lua +++ b/lua/lazyvim/util/root.lua @@ -30,12 +30,13 @@ function M.detectors.lsp(buf) end local roots = {} ---@type string[] for _, client in pairs(LazyVim.lsp.get_clients({ bufnr = buf })) do - -- only check workspace folders, since we're not interested in clients - -- running in single file mode local workspace = client.config.workspace_folders for _, ws in pairs(workspace or {}) do roots[#roots + 1] = vim.uri_to_fname(ws.uri) end + if client.root_dir then + roots[#roots + 1] = client.root_dir + end end return vim.tbl_filter(function(path) path = LazyVim.norm(path) @@ -168,13 +169,14 @@ end -- * lsp root_dir -- * root pattern of filename of the current buffer -- * root pattern of cwd ----@param opts? {normalize?:boolean} +---@param opts? {normalize?:boolean, buf?:number} ---@return string function M.get(opts) - local buf = vim.api.nvim_get_current_buf() + opts = opts or {} + local buf = opts.buf or vim.api.nvim_get_current_buf() local ret = M.cache[buf] if not ret then - local roots = M.detect({ all = false }) + local roots = M.detect({ all = false, buf = buf }) ret = roots[1] and roots[1].paths[1] or vim.uv.cwd() M.cache[buf] = ret end diff --git a/lua/lazyvim/util/telescope.lua b/lua/lazyvim/util/telescope.lua deleted file mode 100644 index bb030627..00000000 --- a/lua/lazyvim/util/telescope.lua +++ /dev/null @@ -1,63 +0,0 @@ ----@class lazyvim.util.telescope.opts ----@field cwd? string|boolean ----@field show_untracked? boolean - ----@class lazyvim.util.telescope ----@overload fun(builtin:string, opts?:lazyvim.util.telescope.opts) -local M = setmetatable({}, { - __call = function(m, ...) - return m.telescope(...) - end, -}) - --- this will return a function that calls telescope. --- cwd will default to lazyvim.util.get_root --- for `files`, git_files or find_files will be chosen depending on .git ----@param builtin string ----@param opts? lazyvim.util.telescope.opts -function M.telescope(builtin, opts) - local params = { builtin = builtin, opts = opts } - return function() - builtin = params.builtin - opts = params.opts - opts = vim.tbl_deep_extend("force", { cwd = LazyVim.root() }, opts or {}) --[[@as lazyvim.util.telescope.opts]] - if builtin == "files" then - if - vim.uv.fs_stat((opts.cwd or vim.uv.cwd()) .. "/.git") - and not vim.uv.fs_stat((opts.cwd or vim.uv.cwd()) .. "/.ignore") - and not vim.uv.fs_stat((opts.cwd or vim.uv.cwd()) .. "/.rgignore") - then - if opts.show_untracked == nil then - opts.show_untracked = true - end - builtin = "git_files" - else - builtin = "find_files" - end - end - if opts.cwd and opts.cwd ~= vim.uv.cwd() then - local function open_cwd_dir() - local action_state = require("telescope.actions.state") - local line = action_state.get_current_line() - M.telescope( - params.builtin, - vim.tbl_deep_extend("force", {}, params.opts or {}, { cwd = false, default_text = line }) - )() - end - ---@diagnostic disable-next-line: inject-field - opts.attach_mappings = function(_, map) - -- opts.desc is overridden by telescope, until it's changed there is this fix - map("i", "", open_cwd_dir, { desc = "Open cwd Directory" }) - return true - end - end - - require("telescope.builtin")[builtin](opts) - end -end - -function M.config_files() - return LazyVim.telescope("find_files", { cwd = vim.fn.stdpath("config") }) -end - -return M diff --git a/lua/lazyvim/util/terminal.lua b/lua/lazyvim/util/terminal.lua index 6d40dc95..87f8553b 100644 --- a/lua/lazyvim/util/terminal.lua +++ b/lua/lazyvim/util/terminal.lua @@ -29,10 +29,10 @@ function M.setup(shell) "-NoLogo -ExecutionPolicy RemoteSigned -Command [Console]::InputEncoding=[Console]::OutputEncoding=[System.Text.UTF8Encoding]::new();$PSDefaultParameterValues['Out-File:Encoding']='utf8';" -- Setting shell redirection - vim.o.shellredir = '2>&1 | %{ "$_" } | Out-File %s; exit $LastExitCode' + vim.o.shellredir = '2>&1 | %%{ "$_" } | Out-File %s; exit $LastExitCode' -- Setting shell pipe - vim.o.shellpipe = '2>&1 | %{ "$_" } | Tee-Object %s; exit $LastExitCode' + vim.o.shellpipe = '2>&1 | %%{ "$_" } | Tee-Object %s; exit $LastExitCode' -- Setting shell quote options vim.o.shellquote = "" @@ -87,6 +87,8 @@ function M.open(cmd, opts) vim.cmd.startinsert() end, }) + + vim.cmd("noh") end return terminals[termkey] diff --git a/lua/lazyvim/util/toggle.lua b/lua/lazyvim/util/toggle.lua index 95bb3e76..4e0ba494 100644 --- a/lua/lazyvim/util/toggle.lua +++ b/lua/lazyvim/util/toggle.lua @@ -1,115 +1,186 @@ ---@class lazyvim.util.toggle local M = {} ----@param silent boolean? ----@param values? {[1]:any, [2]:any} -function M.option(option, silent, values) - if values then - if vim.opt_local[option]:get() == values[1] then - ---@diagnostic disable-next-line: no-unknown - vim.opt_local[option] = values[2] - else - ---@diagnostic disable-next-line: no-unknown - vim.opt_local[option] = values[1] - end - return LazyVim.info("Set " .. option .. " to " .. vim.opt_local[option]:get(), { title = "Option" }) - end - ---@diagnostic disable-next-line: no-unknown - vim.opt_local[option] = not vim.opt_local[option]:get() - if not silent then - if vim.opt_local[option]:get() then - LazyVim.info("Enabled " .. option, { title = "Option" }) - else - LazyVim.warn("Disabled " .. option, { title = "Option" }) - end - end +---@class lazyvim.Toggle +---@field name string +---@field get fun():boolean +---@field set fun(state:boolean) + +---@class lazyvim.Toggle.wrap: lazyvim.Toggle +---@operator call:boolean + +---@param toggle lazyvim.Toggle +function M.wrap(toggle) + return setmetatable(toggle, { + __call = function() + toggle.set(not toggle.get()) + local state = toggle.get() + if state then + LazyVim.info("Enabled " .. toggle.name, { title = toggle.name }) + else + LazyVim.warn("Disabled " .. toggle.name, { title = toggle.name }) + end + return state + end, + }) --[[@as lazyvim.Toggle.wrap]] end -local nu = { number = true, relativenumber = true } -function M.number() - if vim.opt_local.number:get() or vim.opt_local.relativenumber:get() then - nu = { number = vim.opt_local.number:get(), relativenumber = vim.opt_local.relativenumber:get() } - vim.opt_local.number = false - vim.opt_local.relativenumber = false - LazyVim.warn("Disabled line numbers", { title = "Option" }) - else - vim.opt_local.number = nu.number - vim.opt_local.relativenumber = nu.relativenumber - LazyVim.info("Enabled line numbers", { title = "Option" }) - end +---@param lhs string +---@param toggle lazyvim.Toggle +function M.map(lhs, toggle) + local t = M.wrap(toggle) + LazyVim.safe_keymap_set("n", lhs, function() + t() + end, { desc = "Toggle " .. toggle.name }) + M.wk(lhs, toggle) end -local enabled = true -function M.diagnostics() - -- if this Neovim version supports checking if diagnostics are enabled - -- then use that for the current state - if vim.diagnostic.is_enabled then - enabled = vim.diagnostic.is_enabled() - elseif vim.diagnostic.is_disabled then - enabled = not vim.diagnostic.is_disabled() - end - enabled = not enabled - - if enabled then - vim.diagnostic.enable() - LazyVim.info("Enabled diagnostics", { title = "Diagnostics" }) - else - vim.diagnostic.disable() - LazyVim.warn("Disabled diagnostics", { title = "Diagnostics" }) - end -end - ----@param buf? number ----@param value? boolean -function M.inlay_hints(buf, value) - local ih = vim.lsp.buf.inlay_hint or vim.lsp.inlay_hint - if type(ih) == "function" then - ih(buf, value) - elseif type(ih) == "table" and ih.enable then - if value == nil then - value = not ih.is_enabled({ bufnr = buf or 0 }) - end - ih.enable(value, { bufnr = buf }) - end -end - ----@type {k:string, v:any}[] -M._maximized = nil ----@param state boolean? -function M.maximize(state) - if state == (M._maximized ~= nil) then +function M.wk(lhs, toggle) + if not LazyVim.has("which-key.nvim") then return end - if M._maximized then - for _, opt in ipairs(M._maximized) do - vim.o[opt.k] = opt.v + local function safe_get() + local ok, enabled = pcall(toggle.get) + if not ok then + LazyVim.error({ "Failed to get toggle state for **" .. toggle.name .. "**:\n", enabled }, { once = true }) end - M._maximized = nil - vim.cmd("wincmd =") - else - M._maximized = {} - local function set(k, v) - table.insert(M._maximized, 1, { k = k, v = vim.o[k] }) - vim.o[k] = v - end - set("winwidth", 999) - set("winheight", 999) - set("winminwidth", 10) - set("winminheight", 4) - vim.cmd("wincmd =") + return enabled end - -- `QuitPre` seems to be executed even if we quit a normal window, so we don't want that - -- `VimLeavePre` might be another consideration? Not sure about differences between the 2 - vim.api.nvim_create_autocmd("ExitPre", { - once = true, - group = vim.api.nvim_create_augroup("lazyvim_restore_max_exit_pre", { clear = true }), - desc = "Restore width/height when close Neovim while maximized", - callback = function() - M.maximize(false) + require("which-key").add({ + { + lhs, + icon = function() + return safe_get() and { icon = " ", color = "green" } or { icon = " ", color = "yellow" } + end, + desc = function() + return (safe_get() and "Disable " or "Enable ") .. toggle.name + end, + }, + }) +end + +M.treesitter = M.wrap({ + name = "Treesitter Highlight", + get = function() + return vim.b.ts_highlight + end, + set = function(state) + if state then + vim.treesitter.start() + else + vim.treesitter.stop() + end + end, +}) + +---@param buf? boolean +function M.format(buf) + return M.wrap({ + name = "Auto Format (" .. (buf and "Buffer" or "Global") .. ")", + get = function() + if not buf then + return vim.g.autoformat == nil or vim.g.autoformat + end + return LazyVim.format.enabled() + end, + set = function(state) + LazyVim.format.enable(state, buf) end, }) end +---@param opts? {values?: {[1]:any, [2]:any}, name?: string} +function M.option(option, opts) + opts = opts or {} + local name = opts.name or option + local on = opts.values and opts.values[2] or true + local off = opts.values and opts.values[1] or false + return M.wrap({ + name = name, + get = function() + return vim.opt_local[option]:get() == on + end, + set = function(state) + vim.opt_local[option] = state and on or off + end, + }) +end + +local nu = { number = true, relativenumber = true } +M.number = M.wrap({ + name = "Line Numbers", + get = function() + return vim.opt_local.number:get() or vim.opt_local.relativenumber:get() + end, + set = function(state) + if state then + vim.opt_local.number = nu.number + vim.opt_local.relativenumber = nu.relativenumber + else + nu = { number = vim.opt_local.number:get(), relativenumber = vim.opt_local.relativenumber:get() } + vim.opt_local.number = false + vim.opt_local.relativenumber = false + end + end, +}) + +M.diagnostics = M.wrap({ + name = "Diagnostics", + get = function() + return vim.diagnostic.is_enabled and vim.diagnostic.is_enabled() + end, + set = vim.diagnostic.enable, +}) + +M.inlay_hints = M.wrap({ + name = "Inlay Hints", + get = function() + return vim.lsp.inlay_hint.is_enabled({ bufnr = 0 }) + end, + set = function(state) + vim.lsp.inlay_hint.enable(state, { bufnr = 0 }) + end, +}) + +---@type {k:string, v:any}[] +M._maximized = nil +M.maximize = M.wrap({ + name = "Maximize", + get = function() + return M._maximized ~= nil + end, + set = function(state) + if state then + M._maximized = {} + local function set(k, v) + table.insert(M._maximized, 1, { k = k, v = vim.o[k] }) + vim.o[k] = v + end + set("winwidth", 999) + set("winheight", 999) + set("winminwidth", 10) + set("winminheight", 4) + vim.cmd("wincmd =") + -- `QuitPre` seems to be executed even if we quit a normal window, so we don't want that + -- `VimLeavePre` might be another consideration? Not sure about differences between the 2 + vim.api.nvim_create_autocmd("ExitPre", { + once = true, + group = vim.api.nvim_create_augroup("lazyvim_restore_max_exit_pre", { clear = true }), + desc = "Restore width/height when close Neovim while maximized", + callback = function() + M.maximize.set(false) + end, + }) + else + for _, opt in ipairs(M._maximized) do + vim.o[opt.k] = opt.v + end + M._maximized = nil + vim.cmd("wincmd =") + end + end, +}) + setmetatable(M, { __call = function(m, ...) return m.option(...) diff --git a/lua/lazyvim/util/ui.lua b/lua/lazyvim/util/ui.lua index 84ab8ab5..28537bce 100644 --- a/lua/lazyvim/util/ui.lua +++ b/lua/lazyvim/util/ui.lua @@ -78,7 +78,7 @@ function M.foldtext() if not ret or type(ret) == "string" then ret = { { vim.api.nvim_buf_get_lines(0, vim.v.lnum - 1, vim.v.lnum, false)[1], {} } } end - table.insert(ret, { " " .. require("lazyvim.config").icons.misc.dots }) + table.insert(ret, { " " .. LazyVim.config.icons.misc.dots }) if not vim.treesitter.foldtext then return table.concat( @@ -124,7 +124,7 @@ function M.statuscolumn() elseif show_open_folds and not LazyVim.ui.skip_foldexpr[buf] - and vim.treesitter.foldexpr(vim.v.lnum):sub(1, 1) == ">" + and tostring(vim.treesitter.foldexpr(vim.v.lnum)):sub(1, 1) == ">" then -- fold start fold = { text = vim.opt.fillchars:get().foldopen or "", texthl = githl } end @@ -140,10 +140,14 @@ function M.statuscolumn() local is_num = vim.wo[win].number local is_relnum = vim.wo[win].relativenumber if (is_num or is_relnum) and vim.v.virtnum == 0 then - if vim.v.relnum == 0 then - components[2] = is_num and "%l" or "%r" -- the current line + if vim.fn.has("nvim-0.11") == 1 then + components[2] = "%l" -- 0.11 handles both the current and other lines with %l else - components[2] = is_relnum and "%r" or "%l" -- other lines + if vim.v.relnum == 0 then + components[2] = is_num and "%l" or "%r" -- the current line + else + components[2] = is_relnum and "%r" or "%l" -- other lines + end end components[2] = "%=" .. components[2] .. " " -- right align end @@ -227,7 +231,7 @@ function M.bufremove(buf) if vim.bo.modified then local choice = vim.fn.confirm(("Save changes to %q?"):format(vim.fn.bufname()), "&Yes\n&No\n&Cancel") - if choice == 0 then -- Cancel + if choice == 0 or choice == 3 then -- 0 for / and 3 for Cancel return end if choice == 1 then -- Yes diff --git a/release-please-config.json b/release-please-config.json deleted file mode 100644 index 1d1b8b1d..00000000 --- a/release-please-config.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json", - "release-type": "simple", - "extra-files": ["lua/lazyvim/config/init.lua"] -} diff --git a/scripts/test b/scripts/test new file mode 100755 index 00000000..ffbb5405 --- /dev/null +++ b/scripts/test @@ -0,0 +1,3 @@ +#!/bin/env bash + +nvim -l tests/minit.lua --minitest diff --git a/selene.toml b/selene.toml new file mode 100644 index 00000000..5867a2a2 --- /dev/null +++ b/selene.toml @@ -0,0 +1,4 @@ +std="vim" + +[lints] +mixed_table="allow" diff --git a/tests/dd_spec.lua b/tests/dd_spec.lua new file mode 100644 index 00000000..6304e966 --- /dev/null +++ b/tests/dd_spec.lua @@ -0,0 +1,6 @@ +describe("Should not have", function() + it("dd()", function() + local out = vim.fn.system([[/bin/grep --line-number -r '\\bdd(' lua]]) + assert(vim.v.shell_error == 1, "Should not have dd()\n" .. out) + end) +end) diff --git a/tests/extras/lang_spec.lua b/tests/extras/extra_spec.lua similarity index 72% rename from tests/extras/lang_spec.lua rename to tests/extras/extra_spec.lua index 7c81c667..fa2fc9de 100644 --- a/tests/extras/lang_spec.lua +++ b/tests/extras/extra_spec.lua @@ -1,5 +1,7 @@ ---@module 'luassert' +local Icons = require("mini.icons") + local Plugin = require("lazy.core.plugin") _G.LazyVim = require("lazyvim.util") @@ -38,13 +40,10 @@ describe("Extra", function() for _, extra in ipairs(extras) do local name = extra.modname:sub(#"lazyvim.plugins.extras" + 2) describe(name, function() - ---@type any, LazySpecLoader - local mod, spec - it("spec is valid", function() - mod = require(extra.modname) + local mod = require(extra.modname) assert.is_not_nil(mod) - spec = Plugin.Spec.new({ + local spec = Plugin.Spec.new({ { "williamboman/mason.nvim", opts = { ensure_installed = {} } }, { "nvim-treesitter/nvim-treesitter", opts = { ensure_installed = {} } }, mod, @@ -54,10 +53,17 @@ describe("Extra", function() if extra.modname:find("%.lang%.") then it("has recommended set", function() + local mod = require(extra.modname) assert(mod.recommended, "`recommended` not set for " .. extra.modname) end) end + local mod = require(extra.modname) + local spec = Plugin.Spec.new({ + { "williamboman/mason.nvim", opts = { ensure_installed = {} } }, + { "nvim-treesitter/nvim-treesitter", opts = { ensure_installed = {} } }, + mod, + }, { optional = true }) local lspconfig = spec.plugins["nvim-lspconfig"] if lspconfig then it("does not install LSP servers with mason.nvim", function() @@ -94,6 +100,28 @@ describe("Extra", function() ) end) end + + -- Icons + local icons = spec.plugins["mini.icons"] + if icons then + local icon_opts = Plugin.values(icons, "opts", false) or {} + local cats = { "directory", "file", "extension", "filetype", "lsp", "os" } + for _, cat in ipairs(cats) do + local cat_names = Icons.list(cat) + if icon_opts[cat] then + describe("does not set existing icons for " .. cat, function() + for icon_name in pairs(icon_opts[cat]) do + it(icon_name, function() + assert.is_false( + vim.tbl_contains(cat_names, icon_name), + "Icon " .. icon_name .. " already exists:\n" .. vim.inspect({ Icons.get(cat, icon_name) }) + ) + end) + end + end) + end + end + end end) end end) diff --git a/tests/init.lua b/tests/init.lua deleted file mode 100644 index 85deca35..00000000 --- a/tests/init.lua +++ /dev/null @@ -1,56 +0,0 @@ --- DO NOT change the paths and don't remove the colorscheme -local root = vim.fn.fnamemodify("./.tests", ":p") - --- set stdpaths to use .repro -for _, name in ipairs({ "config", "data", "state", "cache" }) do - vim.env[("XDG_%s_HOME"):format(name:upper())] = root .. "/" .. name -end - --- bootstrap lazy -local lazypath = root .. "/plugins/lazy.nvim" -if not vim.loop.fs_stat(lazypath) then - print("Bootstrapping lazy.nvim") - vim.fn.system({ "git", "clone", "--filter=blob:none", "https://github.com/folke/lazy.nvim.git", lazypath }) -end -vim.opt.runtimepath:prepend(lazypath) - --- install plugins -local plugins = { - "LazyVim/starter", - { "nvim-lua/plenary.nvim" }, - { "folke/lazy.nvim" }, - "williamboman/mason-lspconfig.nvim", - "williamboman/mason.nvim", - "nvim-treesitter/nvim-treesitter", -} - -local function main() - print("Installing plugins") - require("lazy").setup(plugins, { - root = root .. "/plugins", - performance = { - rtp = { - reset = false, - }, - }, - }) - - if vim.o.filetype == "lazy" then - vim.cmd.close() - end - - print("Updating plugins") - -- update plugins, wait for it to finish and don't show the output - require("lazy").update({ wait = true, show = false }) - -- require("lazy.core.cache").reset() - - vim.opt.rtp:append(".") -end - -local Util = require("lazy.core.util") -Util.try(main, { - on_error = function(err) - print(err) - os.exit(1) - end, -}) diff --git a/tests/minit.lua b/tests/minit.lua new file mode 100644 index 00000000..88cb4185 --- /dev/null +++ b/tests/minit.lua @@ -0,0 +1,16 @@ +#!/usr/bin/env -S nvim -l + +vim.env.LAZY_STDPATH = ".tests" +load(vim.fn.system("curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua"))() + +-- Setup lazy.nvim +require("lazy.minit").setup({ + spec = { + { dir = vim.uv.cwd() }, + "LazyVim/starter", + "williamboman/mason-lspconfig.nvim", + "williamboman/mason.nvim", + "nvim-treesitter/nvim-treesitter", + { "echasnovski/mini.icons", opts = {} }, + }, +}) diff --git a/tests/run b/tests/run deleted file mode 100755 index 631fb09a..00000000 --- a/tests/run +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh - -nvim --headless -u tests/init.lua -c "PlenaryBustedDirectory tests {init = 'tests//init.lua', sequential = true}" diff --git a/tests/util/lazygit_spec.lua b/tests/util/lazygit_spec.lua new file mode 100644 index 00000000..518e886a --- /dev/null +++ b/tests/util/lazygit_spec.lua @@ -0,0 +1,42 @@ +---@module "luassert" + +_G.LazyVim = require("lazyvim.util") + +-- stylua: ignore +local git_remotes_cases = { + ["https://github.com/LazyVim/LazyVim.git"] = "https://github.com/LazyVim/LazyVim", + ["https://github.com/LazyVim/LazyVim"] = "https://github.com/LazyVim/LazyVim", + ["git@github.com:LazyVim/LazyVim"] = "https://github.com/LazyVim/LazyVim", + ["git@ssh.dev.azure.com:v3/neovim-org/owner/repo"] = "https://dev.azure.com/neovim-org/owner/_git/repo", + ["https://folkelemaitre@bitbucket.org/samiulazim/neovim.git"] = "https://bitbucket.org/samiulazim/neovim", + ["git@bitbucket.org:samiulazim/neovim.git"] = "https://bitbucket.org/samiulazim/neovim", + ["git@gitlab.com:inkscape/inkscape.git"] = "https://gitlab.com/inkscape/inkscape", + ["https://gitlab.com/inkscape/inkscape.git"] = "https://gitlab.com/inkscape/inkscape", + ["git@github.com:torvalds/linux.git"] = "https://github.com/torvalds/linux", + ["https://github.com/torvalds/linux.git"] = "https://github.com/torvalds/linux", + ["git@bitbucket.org:team/repo.git"] = "https://bitbucket.org/team/repo", + ["https://bitbucket.org/team/repo.git"] = "https://bitbucket.org/team/repo", + ["git@gitlab.com:example-group/example-project.git"] = "https://gitlab.com/example-group/example-project", + ["https://gitlab.com/example-group/example-project.git"] = "https://gitlab.com/example-group/example-project", + ["git@ssh.dev.azure.com:v3/org/project/repo"] = "https://dev.azure.com/org/project/_git/repo", + ["https://username@dev.azure.com/org/project/_git/repo"] = "https://dev.azure.com/org/project/_git/repo", + ["ssh://git@ghe.example.com:2222/org/repo.git"] = "https://ghe.example.com/org/repo", + ["https://ghe.example.com/org/repo.git"] = "https://ghe.example.com/org/repo", + ["git-codecommit.us-east-1.amazonaws.com/v1/repos/MyDemoRepo"] = "https://git-codecommit.us-east-1.amazonaws.com/v1/repos/MyDemoRepo", + ["https://git-codecommit.us-east-1.amazonaws.com/v1/repos/MyDemoRepo"] = "https://git-codecommit.us-east-1.amazonaws.com/v1/repos/MyDemoRepo", + ["ssh://git@source.developers.google.com:2022/p/project/r/repo"] = "https://source.developers.google.com/p/project/r/repo", + ["https://source.developers.google.com/p/project/r/repo"] = "https://source.developers.google.com/p/project/r/repo", + ["git@git.sr.ht:~user/repo"] = "https://git.sr.ht/~user/repo", + ["https://git.sr.ht/~user/repo"] = "https://git.sr.ht/~user/repo", + ["git@git.sr.ht:~user/another-repo"] = "https://git.sr.ht/~user/another-repo", + ["https://git.sr.ht/~user/another-repo"] = "https://git.sr.ht/~user/another-repo", +} + +describe("util.lazygit", function() + for remote, expected in pairs(git_remotes_cases) do + it("should parse git remote " .. remote, function() + local url = LazyVim.lazygit.get_url(remote) + assert.are.equal(expected, url) + end) + end +end) diff --git a/tests/util/util_spec.lua b/tests/util/util_spec.lua new file mode 100644 index 00000000..0839eefe --- /dev/null +++ b/tests/util/util_spec.lua @@ -0,0 +1,36 @@ +---@module "luassert" + +local LazyVim = require("lazyvim.util") + +describe("util", function() + local t = 0 + local fn = function(a) + t = t + 1 + return a + end + + local m = LazyVim.memoize(fn) + + it("should memoize a function", function() + local a = m(1) + local b = m(1) + local c = m(2) + assert.are.equal(a, b) + assert.are.equal(a, 1) + assert.are.equal(c, 2) + assert.are.equal(t, 2) + assert.are_not.equal(a, c) + end) + + local f1 = LazyVim.memoize(function() + return 1 + end) + local f2 = LazyVim.memoize(function() + return 2 + end) + + it("should memoize based on the correct key", function() + assert.are.equal(f1(), 1) + assert.are.equal(f2(), 2) + end) +end) diff --git a/vim.toml b/vim.toml new file mode 100644 index 00000000..df7e67e6 --- /dev/null +++ b/vim.toml @@ -0,0 +1,21 @@ +[selene] +base = "lua51" +name = "vim" + +[vim] +any = true + +[jit] +any = true + +[assert] +any = true + +[describe] +any = true + +[it] +any = true + +[before_each.args] +any = true