diff --git a/src/editor/core/cm/bracketBlockSelect.test.ts b/src/editor/core/cm/bracketBlockSelect.test.ts new file mode 100644 index 000000000..44cb4f8d6 --- /dev/null +++ b/src/editor/core/cm/bracketBlockSelect.test.ts @@ -0,0 +1,38 @@ +import { describe, expect, it } from "vitest"; +import { EditorState } from "@codemirror/state"; +import { braceBlock, braceNextTo } from "./bracketBlockSelect"; + +const DOC = "int f(Object raw) {\n if (a) {\n g(b[0]);\n }\n}"; +const state = EditorState.create({ doc: DOC }); + +describe("double-clicking a curly brace", () => { + it("selects the block from the opening brace to its match, both included (IDEA)", () => { + const open = DOC.indexOf("{"); + expect(braceBlock(state, open)).toEqual({ from: open, to: DOC.length }); + }); + + it("selects the same block from the closing brace", () => { + const inner = DOC.indexOf("{", DOC.indexOf("if")); + const close = DOC.indexOf("}"); + expect(braceBlock(state, close)).toEqual({ from: inner, to: close + 1 }); + }); + + it("takes the brace next to the caret the click gives, past the end of the line too", () => { + const open = DOC.indexOf("{"); + const lineEnd = state.doc.line(1).to; + expect(braceNextTo(state, lineEnd, false)).toBe(open); + expect(braceNextTo(state, open, false)).toBe(open); + const close = DOC.lastIndexOf("}"); + expect(braceNextTo(state, close, false)).toBe(close); + // On a word, or away from braces, the double-click selects the word. + expect(braceNextTo(state, open, true)).toBeNull(); + expect(braceNextTo(state, DOC.indexOf("raw"), false)).toBeNull(); + }); + + it("leaves parentheses, brackets, other characters and unmatched braces to the word selection", () => { + expect(braceBlock(state, DOC.indexOf("("))).toBeNull(); + expect(braceBlock(state, DOC.indexOf("["))).toBeNull(); + expect(braceBlock(state, DOC.indexOf("raw"))).toBeNull(); + expect(braceBlock(EditorState.create({ doc: "f {" }), 2)).toBeNull(); + }); +}); diff --git a/src/editor/core/cm/bracketBlockSelect.ts b/src/editor/core/cm/bracketBlockSelect.ts new file mode 100644 index 000000000..3eb55ec78 --- /dev/null +++ b/src/editor/core/cm/bracketBlockSelect.ts @@ -0,0 +1,53 @@ +/** + * A double-click that puts the caret next to a curly brace selects the block it opens or + * closes, both braces included, as IDEA does: past the end of a line ending in `{` too. + * A double-click on a word still selects the word. + */ +import { matchBrackets } from "@codemirror/language"; +import { EditorSelection, Prec, type EditorState } from "@codemirror/state"; +import { EditorView } from "@codemirror/view"; + +/** The range from the brace at `at` to its match, both included, or null when it has none. */ +export function braceBlock(state: EditorState, at: number): { from: number; to: number } | null { + const ch = state.sliceDoc(at, at + 1); + if (ch !== "{" && ch !== "}") return null; + const match = ch === "{" ? matchBrackets(state, at, 1) : matchBrackets(state, at + 1, -1); + if (!match?.matched || !match.end) return null; + return { from: Math.min(match.start.from, match.end.from), to: Math.max(match.start.to, match.end.to) }; +} + +const isBrace = (ch: string) => ch === "{" || ch === "}"; + +/** + * The brace next to the caret position `pos` a click at `x` gives, unless the click is on a + * word character (that double-click selects the word). + */ +export function braceNextTo(state: EditorState, pos: number, onWord: boolean): number | null { + if (onWord) return null; + if (pos > 0 && isBrace(state.sliceDoc(pos - 1, pos))) return pos - 1; + if (isBrace(state.sliceDoc(pos, pos + 1))) return pos; + return null; +} + +/** Whether the click at `x` is on a word character around `pos`. */ +function clickOnWord(view: EditorView, pos: number, x: number): boolean { + for (const at of [pos - 1, pos]) { + if (at < 0 || at >= view.state.doc.length) continue; + const box = view.coordsForChar(at); + if (box && x >= box.left && x <= box.right) return /[\p{L}\p{N}_$]/u.test(view.state.sliceDoc(at, at + 1)); + } + return false; +} + +export const bracketBlockSelect = Prec.high( + EditorView.mouseSelectionStyle.of((view, event) => { + if (event.detail !== 2 || event.button !== 0 || event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) + return null; + const pos = view.posAtCoords({ x: event.clientX, y: event.clientY }); + const at = pos == null ? null : braceNextTo(view.state, pos, clickOnWord(view, pos, event.clientX)); + const block = at == null ? null : braceBlock(view.state, at); + if (!block) return null; + const selection = EditorSelection.single(block.from, block.to); + return { get: () => selection, update: () => false }; + }), +); diff --git a/src/editor/core/cm/indentGuides.test.ts b/src/editor/core/cm/indentGuides.test.ts index 646b6f994..0380601f0 100644 --- a/src/editor/core/cm/indentGuides.test.ts +++ b/src/editor/core/cm/indentGuides.test.ts @@ -5,7 +5,7 @@ import { indentUnit } from "@codemirror/language"; import { codeLenses } from "@/editor/api"; import type { EditorSettings } from "@/bindings"; import { codeLensExtension } from "./codeLens"; -import { guideVars, indentGuides, rainbowIndentGuides } from "./indentGuides"; +import { braceGuide, caretGuide, guideVars, indentGuides, rainbowIndentGuides } from "./indentGuides"; import { heavyExtension } from "./setup"; const SOURCE = [ @@ -46,23 +46,23 @@ describe("indent guides", () => { expect(guideVars(1, 4)).toBeNull(); expect(guideVars(3, 4)).toEqual({ images: "var(--openidea-guide), var(--openidea-guide)", - positions: "calc(2.5px + 4ch) 0, calc(2.5px + 8ch) 0", + positions: "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0", }); }); it("positions each guide the same way on lines of different depth", () => { const v = mount(SOURCE); expect(line(v, 1).classList.contains("cm-openidea-guides")).toBe(false); - expect(line(v, 2).style.getPropertyValue("--openidea-guide-positions")).toBe("calc(2.5px + 4ch) 0"); + expect(line(v, 2).style.getPropertyValue("--openidea-guide-positions")).toBe("calc(0.5px + 4ch) 0"); expect(line(v, 3).style.getPropertyValue("--openidea-guide-positions")).toBe( - "calc(2.5px + 4ch) 0, calc(2.5px + 8ch) 0", + "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0", ); }); it("keeps guides through blank lines inside a block", () => { const v = mount(SOURCE); expect(line(v, 4).style.getPropertyValue("--openidea-guide-positions")).toBe( - "calc(2.5px + 4ch) 0, calc(2.5px + 8ch) 0", + "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0", ); }); @@ -77,18 +77,66 @@ describe("indent guides", () => { ]); const [implLens, fnLens] = [...v.contentDOM.querySelectorAll(".cm-openidea-lens")]; expect(v.contentDOM.classList.contains("cm-openidea-guidesOn")).toBe(true); - expect(fnLens!.style.getPropertyValue("--openidea-guide-positions")).toBe("calc(2.5px + 4ch) 0"); + expect(fnLens!.style.getPropertyValue("--openidea-guide-positions")).toBe("calc(0.5px + 4ch) 0"); expect(implLens!.style.getPropertyValue("--openidea-guide-positions")).toBe(""); }); }); +describe("the caret's indent guide", () => { + const at = (lineNo: number, col: number) => { + const state = EditorState.create({ doc: SOURCE }); + return state.update({ selection: { anchor: state.doc.line(lineNo).from + col } }).state; + }; + + it("is the guide in the caret's column whose block holds the caret line (IDEA)", () => { + // `for` opens the guide at column 4, drawn on lines 3-7 (`if` … its `}`). + expect(caretGuide(at(2, 4), 4)).toEqual({ level: 1, from: 3, to: 7 }); + expect(caretGuide(at(4, 4), 4)).toEqual({ level: 1, from: 3, to: 7 }); + expect(caretGuide(at(4, 8), 4)).toEqual({ level: 2, from: 4, to: 6 }); + }); + + it("is none in column 0, between indent units, in text, or on the closing line", () => { + expect(caretGuide(at(4, 0), 4)).toBeNull(); + expect(caretGuide(at(4, 6), 4)).toBeNull(); + expect(caretGuide(at(2, 12), 4)).toBeNull(); + expect(caretGuide(at(8, 4), 4)).toBeNull(); + }); + + it("is the matched brace colour's guide while the caret is at a brace of a multi-line block", () => { + const state = (pos: number) => EditorState.create({ doc: SOURCE, selection: { anchor: pos } }); + const forOpen = SOURCE.indexOf("{", SOURCE.indexOf("for")); + // `for x in y {`: its guide is at column 4, on lines 3-7. + expect(braceGuide(state(forOpen + 1), 4)).toEqual({ level: 1, from: 3, to: 7 }); + expect(braceGuide(state(forOpen), 4)).toEqual({ level: 1, from: 3, to: 7 }); + const forClose = SOURCE.lastIndexOf(" }") + 4; + expect(braceGuide(state(forClose + 1), 4)).toEqual({ level: 1, from: 3, to: 7 }); + expect(braceGuide(state(SOURCE.indexOf("push")), 4)).toBeNull(); + expect(braceGuide(EditorState.create({ doc: "a {\n b { c }\n}", selection: { anchor: 9 } }), 4)).toBeNull(); + }); + + it("draws the brace guide over the caret's", () => { + const v = mount(SOURCE); + v.dispatch({ selection: { anchor: SOURCE.indexOf("{", SOURCE.indexOf("for")) + 1 } }); + expect(images(line(v, 3))).toBe("var(--openidea-guide-brace), var(--openidea-guide)"); + }); + + it("draws that guide on its lines in the selected colour", () => { + const v = mount(SOURCE); + v.dispatch({ selection: { anchor: v.state.doc.line(4).from + 8 } }); + expect(images(line(v, 3))).toBe("var(--openidea-guide), var(--openidea-guide-active)"); + expect(images(line(v, 6))).toBe("var(--openidea-guide)"); + v.dispatch({ selection: { anchor: v.state.doc.line(4).from + 12 } }); + expect(images(line(v, 3))).toBe("var(--openidea-guide), var(--openidea-guide)"); + }); +}); + describe("rainbow indent guides", () => { it("gives each depth its own image, cycling through the five colours", () => { expect(guideVars(0, 4, true)).toBeNull(); expect(guideVars(1, 4, true)).toBeNull(); expect(guideVars(3, 4, true)).toEqual({ images: "var(--openidea-guide-1), var(--openidea-guide-2)", - positions: "calc(2.5px + 4ch) 0, calc(2.5px + 8ch) 0", + positions: "calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0", }); const deep = guideVars(8, 2, true)!; expect(deep.images.split(", ")).toEqual([1, 2, 3, 4, 5, 1, 2].map((n) => `var(--openidea-guide-${n})`)); @@ -108,7 +156,7 @@ describe("rainbow indent guides", () => { expect(images(line(v, 2))).toBe("var(--openidea-guide-1)"); expect(images(line(v, 3))).toBe("var(--openidea-guide-1), var(--openidea-guide-2)"); expect(images(line(v, 4))).toBe("var(--openidea-guide-1), var(--openidea-guide-2)"); - expect(positions(line(v, 4))).toBe("calc(2.5px + 4ch) 0, calc(2.5px + 8ch) 0"); + expect(positions(line(v, 4))).toBe("calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0"); expect(images(line(v, 6))).toBe("var(--openidea-guide-1)"); }); @@ -122,7 +170,7 @@ describe("rainbow indent guides", () => { spaces.destroy(); const tabs = mount(body("\t"), [EditorState.tabSize.of(4)], rainbowIndentGuides, "\t"); expect(images(deepest(tabs))).toBe(expected); - expect(positions(deepest(tabs)).split(", ")[1]).toBe("calc(2.5px + 8ch) 0"); + expect(positions(deepest(tabs)).split(", ")[1]).toBe("calc(0.5px + 8ch) 0"); }); it("does not count a partial indent unit as a level", () => { @@ -163,7 +211,7 @@ describe("rainbow indent guides", () => { }); const lens = () => view!.contentDOM.querySelector(".cm-openidea-lens")!; expect(images(lens())).toBe("var(--openidea-guide-1), var(--openidea-guide-2)"); - expect(positions(lens())).toBe("calc(2.5px + 4ch) 0, calc(2.5px + 8ch) 0"); + expect(positions(lens())).toBe("calc(0.5px + 4ch) 0, calc(0.5px + 8ch) 0"); view.dispatch({ effects: guides.reconfigure(indentGuides) }); expect(images(lens())).toBe("var(--openidea-guide), var(--openidea-guide)"); }); diff --git a/src/editor/core/cm/indentGuides.ts b/src/editor/core/cm/indentGuides.ts index 1f1c110e5..5bdd4de87 100644 --- a/src/editor/core/cm/indentGuides.ts +++ b/src/editor/core/cm/indentGuides.ts @@ -6,13 +6,17 @@ * so a guide stays straight across lines of different depth. Blank lines take * the smaller level of their neighbours and code lens rows the level of the * line they annotate (`guideVars`), so guides stay continuous. With rainbow - * guides each depth gets its own image, coloured from `--syn-rainbow-*`. + * guides each depth gets its own image, coloured from `--syn-rainbow-*`. The + * guide the caret is on takes the selected colour (`caretGuide`). */ -import { Facet, RangeSetBuilder, type EditorState, type Extension } from "@codemirror/state"; +import { countColumn, Facet, RangeSetBuilder, type EditorState, type Extension } from "@codemirror/state"; import { Decoration, EditorView, ViewPlugin, type DecorationSet, type ViewUpdate } from "@codemirror/view"; -import { getIndentUnit } from "@codemirror/language"; +import { getIndentUnit, matchBrackets } from "@codemirror/language"; import { LINE_INSET } from "./lineInset"; +/** How far (px) a guide sits left of its column, so a caret in that column is right of it (IDEA's indent guide shift). */ +const GUIDE_SHIFT = 2; + /** Number of `--openidea-guide-` rainbow colours; deeper guides repeat them. */ export const GUIDE_COLORS = 5; @@ -22,26 +26,41 @@ export const rainbowGuides = Facet.define({ combine: (values) /** * Values of `--openidea-guide-images` / `--openidea-guide-positions` for an * indentation `levels` deep (in units of `step` columns), or null when it has - * no guides. `.cm-openidea-guides` lines and code lens rows turn them into - * backgrounds (theme.ts). + * no guides; the guide at level `active` takes the selected colour, the one at + * level `brace` the matched brace one. `.cm-openidea-guides` lines and code lens + * rows turn them into backgrounds (theme.ts). */ -export function guideVars(levels: number, step: number, rainbow = false): { images: string; positions: string } | null { +export function guideVars( + levels: number, + step: number, + rainbow = false, + active = 0, + brace = 0, +): { images: string; positions: string } | null { if (levels < 2) return null; const images: string[] = []; const positions: string[] = []; for (let level = 1; level < levels; level++) { - images.push(rainbow ? `var(--openidea-guide-${((level - 1) % GUIDE_COLORS) + 1})` : "var(--openidea-guide)"); - positions.push(`calc(${LINE_INSET}px + ${level * step}ch) 0`); + images.push( + level === brace + ? "var(--openidea-guide-brace)" + : level === active + ? "var(--openidea-guide-active)" + : rainbow + ? `var(--openidea-guide-${((level - 1) % GUIDE_COLORS) + 1})` + : "var(--openidea-guide)", + ); + positions.push(`calc(${LINE_INSET - GUIDE_SHIFT}px + ${level * step}ch) 0`); } return { images: images.join(", "), positions: positions.join(", ") }; } const cache = new Map(); -function guideDeco(levels: number, step: number, rainbow: boolean) { - const key = `${levels}:${step}:${rainbow ? 1 : 0}`; +function guideDeco(levels: number, step: number, rainbow: boolean, active: number, brace: number) { + const key = `${levels}:${step}:${rainbow ? 1 : 0}:${active}:${brace}`; let d = cache.get(key); if (d === undefined) { - const vars = guideVars(levels, step, rainbow); + const vars = guideVars(levels, step, rainbow, active, brace); const style = vars && `--openidea-guide-images: ${vars.images}; --openidea-guide-positions: ${vars.positions}`; d = style ? Decoration.line({ attributes: { class: "cm-openidea-guides", style } }) : null; cache.set(key, d); @@ -71,10 +90,77 @@ function levelOf(state: EditorState, lineNo: number, step: number, dir: 1 | -1): return 0; } +const BLOCK_SCAN = 10_000; + +/** A guide: its level (in indent units) and the lines (`from`..`to`) it is drawn on. */ +export interface Guide { + level: number; + from: number; + to: number; +} + +/** The guide line `start` opens at column `col` (its indentation): down to the last deeper line. */ +function blockGuide(state: EditorState, start: number, col: number, step: number): Guide | null { + if (col === 0 || col % step) return null; + let end = start; + for (let n = start + 1; n <= state.doc.lines && n - start < BLOCK_SCAN; n++) { + const cols = indentColumns(state.doc.line(n).text, state.tabSize); + if (cols === null) continue; + if (cols <= col) break; + end = n; + } + return end === start ? null : { level: col / step, from: start + 1, to: end }; +} + +/** + * The guide the caret is on, as IDEA's `IndentsModel.getCaretIndentGuide`: the caret's + * column is the guide's and its line lies in the guide's block, from the line opening it + * to the last deeper one. + */ +export function caretGuide(state: EditorState, step: number): Guide | null { + const head = state.selection.main.head; + const caretLine = state.doc.lineAt(head); + const col = countColumn(caretLine.text.slice(0, head - caretLine.from), state.tabSize); + if (col === 0 || col % step) return null; + let start = caretLine.number; + for (let i = 0; ; start--, i++) { + if (start < 1 || i > BLOCK_SCAN) return null; + const cols = indentColumns(state.doc.line(start).text, state.tabSize); + if (cols === null || cols > col) continue; + if (cols !== col) return null; + break; + } + const guide = blockGuide(state, start, col, step); + return guide && caretLine.number <= guide.to ? guide : null; +} + +/** + * The guide of the block whose braces the caret is at, while they match on different lines: + * IDEA draws it in the matched brace colour (`MATCHED_BRACES_INDENT_GUIDE_COLOR`). + */ +export function braceGuide(state: EditorState, step: number): Guide | null { + const head = state.selection.main.head; + const match = + matchBrackets(state, head, -1) ?? + (head > 0 ? matchBrackets(state, head - 1, 1) : null) ?? + matchBrackets(state, head, 1) ?? + (head < state.doc.length ? matchBrackets(state, head + 1, -1) : null); + if (!match?.matched || !match.end) return null; + const open = Math.min(match.start.from, match.end.from); + if (state.sliceDoc(open, open + 1) !== "{") return null; + const openLine = state.doc.lineAt(open); + if (openLine.number === state.doc.lineAt(Math.max(match.start.from, match.end.from)).number) return null; + const col = indentColumns(openLine.text, state.tabSize) ?? 0; + return blockGuide(state, openLine.number, col, step); +} + function build(view: EditorView): DecorationSet { const state = view.state; const step = Math.max(1, getIndentUnit(state)); const rainbow = state.facet(rainbowGuides); + const caret = caretGuide(state, step); + const brace = braceGuide(state, step); + const on = (g: Guide | null, n: number) => (g && n >= g.from && n <= g.to ? g.level : 0); const b = new RangeSetBuilder(); for (const { from, to } of view.visibleRanges) { let pos = from; @@ -88,7 +174,7 @@ function build(view: EditorView): DecorationSet { } else { levels = Math.floor(cols / step); } - const deco = guideDeco(levels, step, rainbow); + const deco = guideDeco(levels, step, rainbow, on(caret, line.number), on(brace, line.number)); if (deco) b.add(line.from, line.from, deco); } pos = line.to + 1; @@ -107,6 +193,7 @@ export const indentGuides: Extension = [ update(u: ViewUpdate) { if ( u.docChanged || + u.selectionSet || u.viewportChanged || u.startState.tabSize !== u.state.tabSize || u.startState.facet(rainbowGuides) !== u.state.facet(rainbowGuides) diff --git a/src/editor/core/cm/setup.ts b/src/editor/core/cm/setup.ts index e479bb7a7..2892378f9 100644 --- a/src/editor/core/cm/setup.ts +++ b/src/editor/core/cm/setup.ts @@ -47,6 +47,7 @@ import { caretExtension, fontZoom, methodLinesField, prefsExtension, softWrapAct import { commentTokens } from "./languages"; import { multiCaretMouse } from "./multiCaret"; import { columnModeExtension } from "./columnMode"; +import { bracketBlockSelect } from "./bracketBlockSelect"; import { visibleGoalColumns } from "./verticalMotion"; import { tabKeymap } from "./smartKeys"; import { editorBaseKeymap } from "./baseKeymap"; @@ -376,6 +377,7 @@ export function baseExtensions(o: SetupOptions): Extension { EditorState.allowMultipleSelections.of(true), multiCaretMouse, columnModeExtension, + bracketBlockSelect, visibleGoalColumns, occurrenceSearch, overwriteField, diff --git a/src/editor/core/cm/theme.ts b/src/editor/core/cm/theme.ts index 18f77ab39..3e980f0bb 100644 --- a/src/editor/core/cm/theme.ts +++ b/src/editor/core/cm/theme.ts @@ -137,6 +137,13 @@ export const openideaTheme = EditorView.theme({ "var(--bg-editor-selection-inactive, color-mix(in srgb, var(--accent) 14%, transparent))", "--editor-indent-guide": "var(--border-indent-guide, var(--border))", "--openidea-guide": "linear-gradient(var(--editor-indent-guide), var(--editor-indent-guide))", + // The guide the caret is on (IDEA's Selected indent guide). + "--editor-indent-guide-active": "var(--border-indent-guide-active, var(--editor-indent-guide))", + "--openidea-guide-active": "linear-gradient(var(--editor-indent-guide-active), var(--editor-indent-guide-active))", + // The guide of the block whose braces match at the caret (IDEA's Matched braces indent guide). + "--editor-indent-guide-brace": + "var(--border-indent-guide-brace, var(--bg-matched-brace, var(--editor-indent-guide-active)))", + "--openidea-guide-brace": "linear-gradient(var(--editor-indent-guide-brace), var(--editor-indent-guide-brace))", // Rainbow indent guides: one image per depth, so they follow the colour scheme. ...Object.fromEntries( Array.from({ length: GUIDE_COLORS }, (_, i) => {