Fork changes (v0.10)

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -127,7 +127,7 @@ body:
         })
 
         vim.opt.termguicolors = true
-        vim.cmd("colorscheme " .. (vim.fn.has("nvim-0.8") == 1 and "habamax" or "slate"))
+        vim.cmd("colorscheme habamax")
 
         -- ############################################################################
         -- ### ADD INIT.LUA SETTINGS THAT ARE _NECESSARY_ FOR REPRODUCING THE ISSUE ###

README.md

@@ -17,8 +17,8 @@ for any git rev.
 
 - Git ≥ 2.31.0 (for Git support)
 - Mercurial ≥ 5.4.0 (for Mercurial support)
-- Neovim ≥ 0.7.0 (with LuaJIT)
-- [nvim-web-devicons](https://github.com/nvim-tree/nvim-web-devicons) (optional) For file icons
+- Neovim ≥ 0.10.0 (with LuaJIT)
+- [nvim-web-devicons](https://github.com/nvim-tree/nvim-web-devicons) or [mini.icons](https://github.com/echasnovski/mini.nvim/blob/main/readmes/mini-icons.md) (optional) for file icons
 
 ## Installation
 
@@ -503,6 +503,45 @@ restore the file to the state from the left side of the diff (key binding `X`
 from the file panel by default). The current state of the file is stored in the
 git object database, and a command is echoed that shows how to undo the change.
 
+## Recommended Keymaps
+
+These keymaps are commonly used patterns for working with diffview:
+
+```lua
+-- Toggle diffview open/close
+vim.keymap.set('n', '<leader>dv', function()
+  if next(require('diffview.lib').views) == nil then
+    vim.cmd('DiffviewOpen')
+  else
+    vim.cmd('DiffviewClose')
+  end
+end, { desc = 'Toggle Diffview' })
+
+-- Diff working directory
+vim.keymap.set('n', '<leader>do', '<cmd>DiffviewOpen<cr>', { desc = 'Diffview open' })
+vim.keymap.set('n', '<leader>dc', '<cmd>DiffviewClose<cr>', { desc = 'Diffview close' })
+
+-- File history
+vim.keymap.set('n', '<leader>dh', '<cmd>DiffviewFileHistory %<cr>', { desc = 'File history (current file)' })
+vim.keymap.set('n', '<leader>dH', '<cmd>DiffviewFileHistory<cr>', { desc = 'File history (repo)' })
+
+-- Visual mode: history for selection
+vim.keymap.set('v', '<leader>dh', "<Esc><cmd>'<,'>DiffviewFileHistory --follow<CR>", { desc = 'Range history' })
+
+-- Single line history
+vim.keymap.set('n', '<leader>dl', '<cmd>.DiffviewFileHistory --follow<CR>', { desc = 'Line history' })
+
+-- Diff against main/master branch (useful before merging)
+vim.keymap.set('n', '<leader>dm', function()
+  -- Try main first, fall back to master
+  local handle = io.popen('git rev-parse --verify main 2>/dev/null')
+  local result = handle:read('*a')
+  handle:close()
+  local branch = result ~= '' and 'main' or 'master'
+  vim.cmd('DiffviewOpen ' .. branch)
+end, { desc = 'Diff against main/master' })
+```
+
 ## Tips and FAQ
 
 - **Hide untracked files:**
@@ -524,5 +563,170 @@ git object database, and a command is echoed that shows how to undo the change.
 - **Q: How do I jump between hunks in the diff?**
   - A: Use `[c` and `]c`
   - `:h jumpto-diffs`
+- **Compare against merge-base (PR-style diff):**
+  - `DiffviewOpen origin/main...HEAD --merge-base`
+  - Shows only changes introduced since branching.
+- **Use with [Neogit](https://github.com/NeogitOrg/neogit):**
+  - Configure Neogit with `integrations = { diffview = true }` for seamless
+    integration.
+- **Trace line evolution:**
+  - Visual select lines, then `:'<,'>DiffviewFileHistory --follow`
+  - Or for single line: `:.DiffviewFileHistory --follow`
+- **Better diff display (changes shown as add+delete instead of modification):**
+  - Set Neovim's `diffopt` to use a better algorithm:
+    - `vim.opt.diffopt:append { "algorithm:histogram" }`
+  - Alternatives: `algorithm:patience` or `algorithm:minimal`
+  - This affects how Neovim's built-in diff mode displays changes.
+- **Understanding revision arguments:**
+  - `DiffviewOpen HEAD~5` compares HEAD~5 to working tree (all changes since)
+  - `DiffviewOpen HEAD~5..HEAD` compares HEAD~5 to HEAD (excludes working tree changes)
+  - `DiffviewOpen HEAD~5^..HEAD~5` shows changes within that single commit
+  - For viewing a specific commit's changes, use `DiffviewFileHistory` instead
+- **LSP diagnostics in diff buffers:**
+  - Diagnostics only appear for the working tree (LOCAL) side of diffs.
+  - When comparing commits (e.g., `DiffviewOpen main..HEAD`), neither side is the
+    working tree, so LSP won't attach to those buffers.
+  - To see diagnostics, compare against the working tree: `DiffviewOpen main`
+    (not `main..HEAD`). The right side will show your current files with
+    diagnostics.
+  - Inlay hints are automatically disabled for non-working-tree buffers to
+    prevent position mismatch errors.
+- **VSCode-style character-level highlighting:**
+  - Pair diffview with
+    [diffchar.vim](https://github.com/rickhowe/diffchar.vim) for precise
+    character/word-level diff highlights. See
+    [Companion Plugins > Recommended](#recommended) for setup details.
+- **Customizing default keymaps to avoid conflicts:**
+  - The default keymaps (`<leader>e`, `<leader>b`, `<leader>c*`) may conflict
+    with your configuration. Override them in your setup:
+    ```lua
+    require("diffview").setup({
+      keymaps = {
+        view = {
+          -- Use localleader instead to avoid conflicts
+          { "n", "<localleader>e", actions.focus_files },
+          { "n", "<localleader>b", actions.toggle_files },
+          -- Or disable specific mappings
+          { "n", "<leader>e", false },
+        },
+      },
+    })
+    ```
+
+## Companion Plugins
+
+### Recommended
+
+- **[diffchar.vim](https://github.com/rickhowe/diffchar.vim) (VSCode-style character-level highlighting):**
+  - diffchar.vim enhances diff mode with precise character and word-level
+    highlighting. It automatically activates in diff mode, adding a second layer
+    of highlights on top of Neovim's built-in line-level `DiffChange`
+    backgrounds. This gives VSCode-style dual-layer highlighting: light
+    backgrounds for changed lines plus fine-grained highlights for the exact
+    characters that differ.
+  - diffchar.vim works with diffview out of the box. Install the plugin and open
+    a diff — no additional configuration is needed. You may want to enable
+    visual indicators next to deleted characters to get VSCode-style
+    character-level diffs, or disable diffchar's default keymaps (`<leader>g`,
+    `<leader>p`) if they conflict with your mappings:
+    ```lua
+    {
+      'rickhowe/diffchar.vim',
+      config = function()
+        -- Use bold/underline on adjacent chars instead of virtual blank columns.
+        vim.g.DiffDelPosVisible = 1
+
+        -- Disable diffchar default keymaps.
+        -- See: https://github.com/rickhowe/diffchar.vim/issues/21
+        vim.cmd([[
+          nmap <Leader>g <Nop>
+          nmap <Leader>p <Nop>
+        ]])
+      end,
+    }
+    ```
+  - diffchar supports multiple diff granularities via `g:DiffUnit`: `'Char'`
+    (character-level), `'Word1'` (words separated by non-word characters),
+    `'Word2'` (whitespace-delimited words), and custom delimiter patterns. It
+    also offers multi-colour matching via `g:DiffColors` to visually correlate
+    corresponding changed units across windows.
+
+- **[Telescope](https://github.com/nvim-telescope/telescope.nvim) integration:**
+  - You can use Telescope to select branches or commits for diffview:
+    ```lua
+    -- Diff against a branch selected via Telescope
+    vim.keymap.set('n', '<leader>db', function()
+      require('telescope.builtin').git_branches({
+        attach_mappings = function(_, map)
+          map('i', '<CR>', function(prompt_bufnr)
+            local selection = require('telescope.actions.state').get_selected_entry()
+            require('telescope.actions').close(prompt_bufnr)
+            vim.cmd('DiffviewOpen ' .. selection.value)
+          end)
+          return true
+        end,
+      })
+    end, { desc = 'Diffview branch' })
+
+    -- File history for a commit selected via Telescope
+    vim.keymap.set('n', '<leader>dC', function()
+      require('telescope.builtin').git_commits({
+        attach_mappings = function(_, map)
+          map('i', '<CR>', function(prompt_bufnr)
+            local selection = require('telescope.actions.state').get_selected_entry()
+            require('telescope.actions').close(prompt_bufnr)
+            vim.cmd('DiffviewOpen ' .. selection.value .. '^!')
+          end)
+          return true
+        end,
+      })
+    end, { desc = 'Diffview commit' })
+    ```
+
+### Known Issues
+
+Some plugins may conflict with diffview's window layout or keymaps. Here are
+known issues and workarounds:
+
+- **lens.vim (automatic window resizing):**
+  - [camspiers/lens.vim](https://github.com/camspiers/lens.vim) automatically
+    resizes windows based on focus, which interferes with diffview's layout.
+  - **Workaround:** Configure lens.vim to exclude diffview filetypes:
+    ```lua
+    -- In your lens.vim or lens.nvim config:
+    vim.g['lens#disabled_filetypes'] = {
+      'DiffviewFiles', 'DiffviewFileHistory', 'DiffviewFileHistoryPanel'
+    }
+    ```
+
+- **[nvim-treesitter-context](https://github.com/nvim-treesitter/nvim-treesitter-context):**
+  - Context plugins that show code context at the top of windows can cause
+    visual scrollbind misalignment.
+  - **Workaround:** Configure the plugin to disable itself for diffview buffers
+    using the `on_attach` callback:
+    ```lua
+    require('treesitter-context').setup({
+      on_attach = function(buf)
+        return not vim.b[buf].ts_context_disable
+      end,
+    })
+    ```
+
+- **[vim-markdown](https://github.com/preservim/vim-markdown) (preservim/vim-markdown):**
+  - vim-markdown creates folds for markdown sections. Older versions of
+    diffview set `foldlevel=0` which collapsed these sections, hiding diff
+    content. This has been fixed by setting `foldlevel=99` by default.
+  - If you still experience issues, you can manually set foldlevel in hooks:
+    ```lua
+    require('diffview').setup({
+      hooks = {
+        diff_buf_win_enter = function(bufnr, winid, ctx)
+          if ctx.layout_name == 'diff2_horizontal' then
+            vim.wo[winid].foldlevel = 99
+          end
+        end,
+      },
+    })
+    ```
 
 <!-- vim: set tw=80 -->

doc/diffview.txt

@@ -18,12 +18,13 @@ for any git rev.
 
 USAGE                                           *diffview-usage*
 
-Quick-start: `:DiffviewOpen` to open a Diffview that compares against the
-index.
+Quick-start: `:DiffviewOpen` or `:DiffviewToggle` to open a Diffview that
+compares against the index.
 
 You can have multiple Diffviews open, tracking different git revs. Each Diffview
-opens in its own tabpage. To close and dispose of a Diffview, call either
-`:DiffviewClose` or `:tabclose` while a Diffview is the current tabpage.
+opens in its own tabpage. To close and dispose of a Diffview, call
+`:DiffviewClose`, `:DiffviewToggle`, or `:tabclose` while a Diffview is the
+current tabpage.
 Diffviews are automatically updated:
 
         • Every time you enter a Diffview
@@ -370,6 +371,13 @@ COMMANDS                                        *diffview-commands*
                                                 *:DiffviewClose*
 :DiffviewClose          Close the active Diffview.
 
+                                                *:DiffviewToggle*
+:DiffviewToggle [git-rev] [options] [ -- {paths...}]
+
+        Alias for `:DiffviewOpen` when the current tabpage is not a Diffview,
+        otherwise acts as an alias for `:DiffviewClose`. Accepts the same
+        arguments as `:DiffviewOpen`.
+
                                                 *:DiffviewToggleFiles*
 :DiffviewToggleFiles    Toggles the file panel.
 

doc/diffview_defaults.txt

@@ -7,13 +7,28 @@ DEFAULT CONFIG                                  *diffview.defaults*
     enhanced_diff_hl = false, -- See |diffview-config-enhanced_diff_hl|
     git_cmd = { "git" },      -- The git executable followed by default args.
     hg_cmd = { "hg" },        -- The hg executable followed by default args.
-    use_icons = true,         -- Requires nvim-web-devicons
+    use_icons = true,         -- Requires nvim-web-devicons or mini.icons
     show_help_hints = true,   -- Show hints for how to open the help panel
     watch_index = true,       -- Update views and index buffers when the git index changes.
+    hide_merge_artifacts = false, -- Hide merge artifact files (*.orig, *.BACKUP.*, *.BASE.*, *.LOCAL.*, *.REMOTE.*)
+    auto_close_on_empty = false, -- Close diffview when the last file is staged/resolved
     icons = {                 -- Only applies when use_icons is true.
       folder_closed = "",
       folder_open = "",
     },
+    status_icons = {          -- Configure icons for git status letters.
+      ["A"] = "A",            -- Added
+      ["?"] = "?",            -- Untracked
+      ["M"] = "M",            -- Modified
+      ["R"] = "R",            -- Renamed
+      ["C"] = "C",            -- Copied
+      ["T"] = "T",            -- Type changed
+      ["U"] = "U",            -- Unmerged
+      ["X"] = "X",            -- Unknown
+      ["D"] = "D",            -- Deleted
+      ["B"] = "B",            -- Broken
+      ["!"] = "!",            -- Ignored
+    },
     signs = {
       fold_closed = "",
       fold_open = "",
@@ -60,6 +75,7 @@ DEFAULT CONFIG                                  *diffview.defaults*
         width = 35,
         win_opts = {},
       },
+      show = true,                        -- Show the file panel when opening Diffview.
     },
     file_history_panel = {
       log_options = {   -- See |diffview-config-log_options|
@@ -81,6 +97,7 @@ DEFAULT CONFIG                                  *diffview.defaults*
         height = 16,
         win_opts = {},
       },
+      date_format = "auto", -- Date format: "auto" | "relative" | "iso"
     },
     commit_log_panel = {
       win_config = {},  -- See |diffview-config-win_config|