Merge pull request #165 from lambdalisue/add-ginbame

feat: Add GinBlame command for interactive git blame navigation

Author: lambdalisue

CLAUDE.md

@@ -0,0 +1,54 @@
+# Coding Guidelines for vim-gin
+
+## Comments
+
+**All code comments MUST be written in English.**
+
+This applies to:
+
+- Function/class documentation comments
+- Inline comments explaining logic
+- TODO/FIXME/NOTE comments
+- Any other comment in the codebase
+
+### Rationale
+
+- Ensures consistency across the codebase
+- Makes the code accessible to international contributors
+- Follows common open-source project conventions
+
+### Examples
+
+Good example:
+
+```
+// Disable visual features that affect line number display
+await disableVisualLineModifications(denops, bufnr);
+```
+
+Bad example (using non-English comments):
+
+```
+// Disable visual line modifications
+await disableVisualLineModifications(denops, bufnr);
+```
+
+Good example (JSDoc):
+
+```
+/**
+ * Parse git blame porcelain output
+ * @param content - Raw output from git blame --porcelain
+ * @returns Parsed blame result with commits and lines
+ */
+```
+
+Bad example (non-English comments):
+
+```
+/**
+ * Git blame の porcelain 出力を解析する
+ * @param content - git blame --porcelain の出力
+ * @returns パースされた blame 結果
+ */
+```

after/ftplugin/gin-blame.vim

@@ -0,0 +1,33 @@
+" This file is in after/ftplugin/ to ensure it runs AFTER other filetypes' ftplugin
+" For compound filetypes like 'typescript.gin-blame', Vim loads:
+"   1. ftplugin/typescript.vim
+"   2. ftplugin/gin-blame.vim
+"   3. after/ftplugin/typescript.vim
+"   4. after/ftplugin/gin-blame.vim  <- This ensures gin-blame mappings override others
+" This is necessary because some filetypes (e.g. typescript) may define <C-O>/<C-I> mappings
+" that would conflict with gin-blame's history navigation.
+
+if exists('b:did_ftplugin_gin_blame_after')
+  finish
+endif
+let b:did_ftplugin_gin_blame_after = 1
+
+" Define Plug mappings for this buffer
+nnoremap <buffer> <silent> <Plug>(gin-blame-switch-commit) <Cmd>call denops#notify('gin', 'blame:switch_to_commit', [])<CR>
+nnoremap <buffer> <silent> <Plug>(gin-blame-navigate-older) <Cmd>call denops#notify('gin', 'blame:navigate_history', ['older'])<CR>
+nnoremap <buffer> <silent> <Plug>(gin-blame-navigate-newer) <Cmd>call denops#notify('gin', 'blame:navigate_history', ['newer'])<CR>
+
+" Default mappings (can be disabled with g:gin_blame_disable_default_mappings)
+if !get(g:, 'gin_blame_disable_default_mappings', 0)
+  nmap <buffer> <CR> <Plug>(gin-blame-switch-commit)
+  nmap <buffer> <C-O> <Plug>(gin-blame-navigate-older)
+  nmap <buffer> <C-I> <Plug>(gin-blame-navigate-newer)
+endif
+
+" Undo ftplugin settings
+let b:undo_ftplugin_gin_blame_after = 'silent! nunmap <buffer> <CR> |'
+      \ . ' silent! nunmap <buffer> <C-O> |'
+      \ . ' silent! nunmap <buffer> <C-I> |'
+      \ . ' silent! unmap <buffer> <Plug>(gin-blame-switch-commit) |'
+      \ . ' silent! unmap <buffer> <Plug>(gin-blame-navigate-older) |'
+      \ . ' silent! unmap <buffer> <Plug>(gin-blame-navigate-newer)'

denops/gin/command/blame/buffer_utils.ts

@@ -0,0 +1,117 @@
+import type { Denops } from "jsr:@denops/std@^7.0.0";
+import * as fn from "jsr:@denops/std@^7.0.0/function";
+import * as vars from "jsr:@denops/std@^7.0.0/variable";
+import {
+  type BufnameParams,
+  parse as parseBufname,
+} from "jsr:@denops/std@^7.0.0/bufname";
+import type { GitBlameLine, GitBlameResult } from "./parser.ts";
+
+/**
+ * Information about the current blame buffer context
+ */
+export type BlameBufferContext = {
+  bufnrCurrent: number;
+  bufnrNav: number;
+  bufnrBlame: number;
+  scheme: string;
+  expr: string;
+  params: BufnameParams | undefined;
+  fileFragment: string;
+  blameResult: GitBlameResult;
+};
+
+/**
+ * Get blame buffer context from current buffer
+ */
+export async function getBlameContext(
+  denops: Denops,
+): Promise<BlameBufferContext> {
+  const bufnrCurrent = await fn.bufnr(denops);
+  const bufnameCurrent = await fn.bufname(denops, bufnrCurrent);
+  const { scheme, expr, params } = parseBufname(bufnameCurrent);
+
+  // Determine which buffer we're in and get the paired buffers
+  let bufnrNav: number;
+  let bufnrBlame: number;
+
+  if (scheme === "ginblamenav") {
+    bufnrNav = bufnrCurrent;
+    const bufnameBlame = await vars.b.get(denops, "gin_blame_file_bufname") as
+      | string
+      | undefined;
+    if (!bufnameBlame) {
+      throw new Error("Cannot find associated ginblame buffer");
+    }
+    bufnrBlame = await fn.bufnr(denops, bufnameBlame);
+  } else if (scheme === "ginblame") {
+    bufnrBlame = bufnrCurrent;
+    const bufnameNav = await vars.b.get(denops, "gin_blame_nav_bufname") as
+      | string
+      | undefined;
+    if (!bufnameNav) {
+      throw new Error("Cannot find associated ginblamenav buffer");
+    }
+    bufnrNav = await fn.bufnr(denops, bufnameNav);
+  } else {
+    throw new Error(
+      "This command can only be called from ginblame or ginblamenav buffer",
+    );
+  }
+
+  const fileFragment = await vars.b.get(denops, "gin_blame_file_fragment") as
+    | string
+    | undefined;
+  if (!fileFragment) {
+    throw new Error("File fragment not found");
+  }
+
+  const blameResult = await vars.b.get(denops, "gin_blame_result") as
+    | GitBlameResult
+    | undefined;
+  if (!blameResult) {
+    throw new Error("Blame result not found");
+  }
+
+  if (bufnrBlame === -1) {
+    throw new Error("Ginblame buffer not found");
+  }
+
+  return {
+    bufnrCurrent,
+    bufnrNav,
+    bufnrBlame,
+    scheme,
+    expr,
+    params,
+    fileFragment,
+    blameResult,
+  };
+}
+
+/**
+ * Get blame line from current cursor position using lineMap
+ * Works for both ginblamenav and ginblame buffers
+ */
+export async function getBlameLine(
+  denops: Denops,
+  _scheme: string,
+  lnum: number,
+  _blameResult: GitBlameResult,
+): Promise<{ blameLine: GitBlameLine; relativeOffset: number } | null> {
+  // Get the line map (physical line -> GitBlameLine)
+  const lineMap = await vars.b.get(denops, "gin_blame_line_map") as
+    | Record<number, GitBlameLine>
+    | undefined;
+  if (!lineMap) {
+    return null;
+  }
+
+  // Direct lookup by physical line number
+  const blameLine = lineMap[lnum];
+  if (!blameLine) {
+    return null; // Empty line or divider
+  }
+
+  return { blameLine, relativeOffset: 0 };
+}

denops/gin/command/blame/command.ts

@@ -0,0 +1,50 @@
+import type { Denops } from "jsr:@denops/std@^7.0.0";
+import * as path from "jsr:@std/path@^1.0.0";
+import * as buffer from "jsr:@denops/std@^7.0.0/buffer";
+import * as option from "jsr:@denops/std@^7.0.0/option";
+import { format as formatBufname } from "jsr:@denops/std@^7.0.0/bufname";
+import { unnullish } from "jsr:@lambdalisue/unnullish@^1.0.0";
+import { findWorktreeFromDenops } from "../../git/worktree.ts";
+
+export type ExecOptions = {
+  worktree?: string;
+  commitish?: string;
+  emojify?: boolean;
+  opener?: string;
+  cmdarg?: string;
+  mods?: string;
+  bang?: boolean;
+};
+
+export async function exec(
+  denops: Denops,
+  filename: string,
+  options: ExecOptions = {},
+): Promise<buffer.OpenResult> {
+  const verbose = await option.verbose.get(denops);
+
+  const worktree = await findWorktreeFromDenops(denops, {
+    worktree: options.worktree,
+    verbose: !!verbose,
+  });
+
+  const relpath = path.isAbsolute(filename)
+    ? path.relative(worktree, filename)
+    : filename;
+
+  const bufname = formatBufname({
+    scheme: "ginblame",
+    expr: worktree,
+    params: {
+      commitish: options.commitish,
+      emojify: unnullish(options.emojify, (v) => v ? "" : undefined),
+    },
+    fragment: relpath,
+  });
+  return await buffer.open(denops, bufname.toString(), {
+    opener: options.opener ?? "tabedit",
+    cmdarg: options.cmdarg,
+    mods: options.mods,
+    bang: options.bang,
+  });
+}