M4.8: merge conflicts with a three-pane resolve view
Backend (crates/vcs/src/merge.rs, cmd/git_merge.rs via start_with):
git.merge {branch} -> {result: merged|upToDate|conflicts, conflicts},
git.mergeAbort, git.conflictVersions {path} -> {base?, ours, theirs,
binary, tooLarge} from the index stages :1:/:2:/:3:, git.markResolved
{paths}. Repo::lock becomes pub(crate) so merge and abort hold the
mutation lock.
UI (ui/src/components/vcs/merge/): merge dialog with branch picker,
conflicts list from the shared status store, a three-pane resolve view
(ours / editable result / theirs) with accept left/right per chunk,
accept all, previous/next conflict, Apply through the file's buffer then
mark resolved, keep-a-side for modify/delete, abort after confirmation.
Own three-way line merge on @codemirror/merge's diff. UI commands
vcs.merge, vcs.resolveConflicts, vcs.abortMerge (no default shortcuts);
the Changes window opens conflicted rows in the resolve view.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
74c674ed12
commit
d82e57b3ac
26 changed files with 3872 additions and 16 deletions
513
ui/src/components/vcs/merge/resolveView.ts
Normal file
513
ui/src/components/vcs/merge/resolveView.ts
Normal file
|
|
@ -0,0 +1,513 @@
|
|||
/**
|
||||
* The three editors of the resolve view (M4.8): ours (left, read-only),
|
||||
* the result (middle, editable) and theirs (right, read-only).
|
||||
*
|
||||
* - **Blocks:** built by `merge3` (`diff3.ts`). Non-conflicting changes are
|
||||
* in the result from the start; each conflict is a chunk whose range in
|
||||
* the result starts as the base's lines.
|
||||
* - **Chunks in the result:** a state field keeps each chunk's range,
|
||||
* mapped through every edit (the start sticks before text inserted at it,
|
||||
* the end after, so typing at a chunk's edge extends it). Its state comes
|
||||
* from its text: open while it is the base's, taken from ours or theirs
|
||||
* while it equals that side, edited by hand otherwise.
|
||||
* - **Accepting:** {@link ResolveView.accept} replaces a chunk's range with
|
||||
* that side's lines; it is one undoable change of the result, and undo
|
||||
* opens the chunk again. The side
|
||||
* panes show a button in the gutter at the first line of every open
|
||||
* chunk ("»" left, "«" right); a click accepts it.
|
||||
* - **Colours:** only `--lt-*` tokens: open conflicts tinted with
|
||||
* `--lt-vcs-conflicted`, accepted chunks and non-conflicting changes with
|
||||
* `--lt-vcs-modified`.
|
||||
* - **Navigation:** {@link ResolveView.go} moves to the next or previous
|
||||
* open chunk (wrapping), selects it in the result and scrolls all three
|
||||
* editors to it.
|
||||
*/
|
||||
import { EditorState, RangeSetBuilder, StateEffect, StateField, type Extension, type Text } from "@codemirror/state";
|
||||
import { Decoration, EditorView, GutterMarker, gutter, type DecorationSet } from "@codemirror/view";
|
||||
import { basicSetup } from "codemirror";
|
||||
import { lutraEditorTheme } from "../../editor/extensions";
|
||||
import { languageExtensions } from "../../editor/language";
|
||||
import { merge3, resultUnits, splitUnits, type MergeBlock } from "./diff3";
|
||||
|
||||
/** Which side a chunk was taken from, or how else it was settled. */
|
||||
export type ChunkState = "open" | "ours" | "theirs" | "edited";
|
||||
|
||||
/** A conflict chunk: its text on each side and its place in each document. */
|
||||
export interface Chunk {
|
||||
/** Our text. */
|
||||
ours: string;
|
||||
/** Their text. */
|
||||
theirs: string;
|
||||
/** Range in the ours document. */
|
||||
oursFrom: number;
|
||||
/** End in the ours document. */
|
||||
oursTo: number;
|
||||
/** Range in the theirs document. */
|
||||
theirsFrom: number;
|
||||
/** End in the theirs document. */
|
||||
theirsTo: number;
|
||||
}
|
||||
|
||||
/** A chunk's live range in the result. */
|
||||
interface Range {
|
||||
/** Start in the result. */
|
||||
from: number;
|
||||
/** End in the result. */
|
||||
to: number;
|
||||
}
|
||||
|
||||
/** A chunk's live range and state in the result. */
|
||||
export interface Live extends Range {
|
||||
/** Its state, read from the text in its range. */
|
||||
state: ChunkState;
|
||||
}
|
||||
|
||||
/** A highlighted range of a side document. */
|
||||
interface Marked {
|
||||
/** Start. */
|
||||
from: number;
|
||||
/** End. */
|
||||
to: number;
|
||||
/** A conflict (else a non-conflicting change). */
|
||||
conflict: boolean;
|
||||
}
|
||||
|
||||
/** The laid-out merge: documents, chunks and highlights. */
|
||||
export interface Layout {
|
||||
/** The ours document. */
|
||||
ours: string;
|
||||
/** The theirs document. */
|
||||
theirs: string;
|
||||
/** The initial result. */
|
||||
result: string;
|
||||
/** The conflict chunks in order. */
|
||||
chunks: Chunk[];
|
||||
/** Initial result range of each chunk. */
|
||||
resultRanges: { from: number; to: number }[];
|
||||
/** Highlights of the ours document. */
|
||||
oursMarks: Marked[];
|
||||
/** Highlights of the theirs document. */
|
||||
theirsMarks: Marked[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Lays out a merge of the three texts.
|
||||
*
|
||||
* @param base - the base text, null when there is none.
|
||||
* @param ours - our text.
|
||||
* @param theirs - their text.
|
||||
*/
|
||||
export function layout(base: string | null, ours: string, theirs: string): Layout {
|
||||
const blocks: MergeBlock[] = merge3(base === null ? null : splitUnits(base), splitUnits(ours), splitUnits(theirs));
|
||||
const out: Layout = { ours: "", theirs: "", result: "", chunks: [], resultRanges: [], oursMarks: [], theirsMarks: [] };
|
||||
for (const block of blocks) {
|
||||
const oursText = block.ours.join("");
|
||||
const theirsText = block.theirs.join("");
|
||||
const resultText = resultUnits(block).join("");
|
||||
const oursFrom = out.ours.length;
|
||||
const theirsFrom = out.theirs.length;
|
||||
const resultFrom = out.result.length;
|
||||
out.ours += oursText;
|
||||
out.theirs += theirsText;
|
||||
out.result += resultText;
|
||||
if (block.kind === "conflict") {
|
||||
out.chunks.push({
|
||||
ours: oursText,
|
||||
theirs: theirsText,
|
||||
oursFrom,
|
||||
oursTo: out.ours.length,
|
||||
theirsFrom,
|
||||
theirsTo: out.theirs.length,
|
||||
});
|
||||
out.resultRanges.push({ from: resultFrom, to: out.result.length });
|
||||
}
|
||||
if (block.kind === "conflict" || block.kind === "ours" || block.kind === "both") {
|
||||
out.oursMarks.push({ from: oursFrom, to: out.ours.length, conflict: block.kind === "conflict" });
|
||||
}
|
||||
if (block.kind === "conflict" || block.kind === "theirs" || block.kind === "both") {
|
||||
out.theirsMarks.push({ from: theirsFrom, to: out.theirs.length, conflict: block.kind === "conflict" });
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Marks the chunks resolved in a side pane (`true` = open). */
|
||||
const setOpen = StateEffect.define<boolean[]>();
|
||||
|
||||
/** Line decorations by class. */
|
||||
const lineDecos = {
|
||||
conflict: Decoration.line({ class: "lt-merge-conflict" }),
|
||||
change: Decoration.line({ class: "lt-merge-change" }),
|
||||
resolved: Decoration.line({ class: "lt-merge-resolved" }),
|
||||
};
|
||||
|
||||
/**
|
||||
* Adds line decorations for the lines a range covers (one line for an
|
||||
* empty range).
|
||||
*
|
||||
* @param doc - the document.
|
||||
* @param from - start of the range.
|
||||
* @param to - end of the range.
|
||||
* @param add - receives each line start.
|
||||
*/
|
||||
function eachLine(doc: Text, from: number, to: number, add: (lineStart: number) => void): void {
|
||||
const first = doc.lineAt(Math.min(from, doc.length));
|
||||
const last = to > from ? doc.lineAt(Math.min(Math.max(to - 1, from), doc.length)) : first;
|
||||
for (let n = first.number; n <= last.number; n += 1) {
|
||||
add(doc.line(n).from);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds line decorations from ranges.
|
||||
*
|
||||
* @param doc - the document.
|
||||
* @param ranges - ranges with their decoration, in document order.
|
||||
*/
|
||||
function lineSet(doc: Text, ranges: { from: number; to: number; deco: Decoration }[]): DecorationSet {
|
||||
const builder = new RangeSetBuilder<Decoration>();
|
||||
let last = -1;
|
||||
for (const range of ranges) {
|
||||
eachLine(doc, range.from, range.to, (start) => {
|
||||
if (start > last) {
|
||||
builder.add(start, start, range.deco);
|
||||
last = start;
|
||||
}
|
||||
});
|
||||
}
|
||||
return builder.finish();
|
||||
}
|
||||
|
||||
/** The accept button in a side pane's gutter. */
|
||||
class AcceptMarker extends GutterMarker {
|
||||
/**
|
||||
* @param glyph - `»` or `«`.
|
||||
* @param label - its accessible name.
|
||||
*/
|
||||
constructor(
|
||||
readonly glyph: string,
|
||||
readonly label: string,
|
||||
) {
|
||||
super();
|
||||
}
|
||||
|
||||
/** @param other - another marker. */
|
||||
override eq(other: GutterMarker): boolean {
|
||||
return other instanceof AcceptMarker && other.glyph === this.glyph && other.label === this.label;
|
||||
}
|
||||
|
||||
/** The button. */
|
||||
override toDOM(): Node {
|
||||
const button = document.createElement("button");
|
||||
button.type = "button";
|
||||
button.className = "lt-merge-accept";
|
||||
button.textContent = this.glyph;
|
||||
button.title = this.label;
|
||||
button.setAttribute("aria-label", this.label);
|
||||
button.tabIndex = -1;
|
||||
return button;
|
||||
}
|
||||
}
|
||||
|
||||
/** Colours of the three editors, from tokens only. */
|
||||
export const resolveTheme: Extension = EditorView.theme({
|
||||
".lt-merge-conflict": { backgroundColor: "color-mix(in srgb, var(--lt-vcs-conflicted) 18%, var(--lt-editor-bg))" },
|
||||
".lt-merge-change": { backgroundColor: "color-mix(in srgb, var(--lt-vcs-modified) 12%, var(--lt-editor-bg))" },
|
||||
".lt-merge-resolved": { backgroundColor: "color-mix(in srgb, var(--lt-vcs-modified) 18%, var(--lt-editor-bg))" },
|
||||
".lt-merge-accept": {
|
||||
font: "inherit",
|
||||
lineHeight: "1",
|
||||
padding: "0 4px",
|
||||
border: "1px solid var(--lt-border)",
|
||||
borderRadius: "3px",
|
||||
color: "var(--lt-fg)",
|
||||
background: "var(--lt-bg)",
|
||||
cursor: "pointer",
|
||||
},
|
||||
".lt-merge-accept:hover": { background: "color-mix(in srgb, var(--lt-accent) 25%, var(--lt-bg))" },
|
||||
});
|
||||
|
||||
/** Labels of the gutter buttons. */
|
||||
export interface ResolveLabels {
|
||||
/** The ours pane's button. */
|
||||
acceptOurs: string;
|
||||
/** The theirs pane's button. */
|
||||
acceptTheirs: string;
|
||||
}
|
||||
|
||||
/** Where the three editors go and what they report. */
|
||||
export interface ResolveOptions {
|
||||
/** The file's path, for its language. */
|
||||
path: string;
|
||||
/** The base text, null when there is none. */
|
||||
base: string | null;
|
||||
/** Our text. */
|
||||
ours: string;
|
||||
/** Their text. */
|
||||
theirs: string;
|
||||
/** Element of the ours editor. */
|
||||
oursHost: HTMLElement;
|
||||
/** Element of the result editor. */
|
||||
resultHost: HTMLElement;
|
||||
/** Element of the theirs editor. */
|
||||
theirsHost: HTMLElement;
|
||||
/** Gutter button labels. */
|
||||
labels: ResolveLabels;
|
||||
/** Called after every change of a chunk's state, with the open count. */
|
||||
onChange: (open: number) => void;
|
||||
}
|
||||
|
||||
/** The three editors of one file. */
|
||||
export class ResolveView {
|
||||
/** The ours editor. */
|
||||
readonly oursView: EditorView;
|
||||
/** The result editor. */
|
||||
readonly resultView: EditorView;
|
||||
/** The theirs editor. */
|
||||
readonly theirsView: EditorView;
|
||||
/** The laid-out merge. */
|
||||
readonly layout: Layout;
|
||||
/** The chunk navigated to last; -1 before any. */
|
||||
current = -1;
|
||||
/** Reports changes. */
|
||||
private readonly onChange: (open: number) => void;
|
||||
/** The chunks' field in the result. */
|
||||
private readonly field: StateField<Range[]>;
|
||||
/** Each chunk's initial text in the result (the base's lines). */
|
||||
private readonly bases: string[];
|
||||
/** The open flags' field of the side panes. */
|
||||
private readonly openField: StateField<boolean[]>;
|
||||
|
||||
/** @param options - hosts, texts and callbacks. */
|
||||
constructor(options: ResolveOptions) {
|
||||
this.onChange = options.onChange;
|
||||
const lay = layout(options.base, options.ours, options.theirs);
|
||||
this.layout = lay;
|
||||
const base = lay.resultRanges.map((r) => lay.result.slice(r.from, r.to));
|
||||
this.bases = base;
|
||||
const field = StateField.define<Range[]>({
|
||||
create: () => lay.resultRanges.map((r) => ({ ...r })),
|
||||
update(ranges, tr) {
|
||||
if (!tr.docChanged) {
|
||||
return ranges;
|
||||
}
|
||||
return ranges.map((range) => {
|
||||
const from = tr.changes.mapPos(range.from, -1);
|
||||
return { from, to: Math.max(from, tr.changes.mapPos(range.to, 1)) };
|
||||
});
|
||||
},
|
||||
provide: (f) =>
|
||||
EditorView.decorations.from(f, (ranges) => (view: EditorView) =>
|
||||
lineSet(
|
||||
view.state.doc,
|
||||
ranges.map((r, i) => ({
|
||||
from: r.from,
|
||||
to: r.to,
|
||||
deco: view.state.doc.sliceString(r.from, r.to) === base[i] ? lineDecos.conflict : lineDecos.resolved,
|
||||
})),
|
||||
),
|
||||
),
|
||||
});
|
||||
this.field = field;
|
||||
const openField = StateField.define<boolean[]>({
|
||||
create: () => lay.chunks.map(() => true),
|
||||
update(flags, tr) {
|
||||
for (const effect of tr.effects) {
|
||||
if (effect.is(setOpen)) {
|
||||
return effect.value;
|
||||
}
|
||||
}
|
||||
return flags;
|
||||
},
|
||||
});
|
||||
this.openField = openField;
|
||||
const language = languageExtensions(options.path);
|
||||
const readOnly = [EditorState.readOnly.of(true), EditorView.editable.of(false)];
|
||||
const side = (which: "ours" | "theirs"): Extension => {
|
||||
const marks = which === "ours" ? lay.oursMarks : lay.theirsMarks;
|
||||
const marker = new AcceptMarker(which === "ours" ? "»" : "«", which === "ours" ? options.labels.acceptOurs : options.labels.acceptTheirs);
|
||||
const starts = lay.chunks.map((c) => (which === "ours" ? c.oursFrom : c.theirsFrom));
|
||||
return [
|
||||
basicSetup,
|
||||
lutraEditorTheme,
|
||||
language,
|
||||
resolveTheme,
|
||||
readOnly,
|
||||
openField,
|
||||
StateField.define<DecorationSet>({
|
||||
create: (state) =>
|
||||
lineSet(
|
||||
state.doc,
|
||||
marks.map((m) => ({ from: m.from, to: m.to, deco: m.conflict ? lineDecos.conflict : lineDecos.change })),
|
||||
),
|
||||
update: (set) => set,
|
||||
provide: (f) => EditorView.decorations.from(f),
|
||||
}),
|
||||
gutter({
|
||||
class: "lt-merge-gutter",
|
||||
lineMarker: (view, line) => {
|
||||
const flags = view.state.field(openField);
|
||||
const index = starts.findIndex(
|
||||
(start, i) => flags[i] === true && view.state.doc.lineAt(Math.min(start, view.state.doc.length)).from === line.from,
|
||||
);
|
||||
return index >= 0 ? marker : null;
|
||||
},
|
||||
lineMarkerChange: (update) => update.transactions.some((tr) => tr.effects.some((e) => e.is(setOpen))),
|
||||
domEventHandlers: {
|
||||
mousedown: (view, line) => {
|
||||
const flags = view.state.field(openField);
|
||||
const index = starts.findIndex(
|
||||
(start, i) => flags[i] === true && view.state.doc.lineAt(Math.min(start, view.state.doc.length)).from === line.from,
|
||||
);
|
||||
if (index < 0) {
|
||||
return false;
|
||||
}
|
||||
this.accept(index, which);
|
||||
return true;
|
||||
},
|
||||
},
|
||||
}),
|
||||
];
|
||||
};
|
||||
this.oursView = new EditorView({ parent: options.oursHost, state: EditorState.create({ doc: lay.ours, extensions: side("ours") }) });
|
||||
this.theirsView = new EditorView({ parent: options.theirsHost, state: EditorState.create({ doc: lay.theirs, extensions: side("theirs") }) });
|
||||
this.resultView = new EditorView({
|
||||
parent: options.resultHost,
|
||||
state: EditorState.create({
|
||||
doc: lay.result,
|
||||
extensions: [
|
||||
basicSetup,
|
||||
lutraEditorTheme,
|
||||
language,
|
||||
resolveTheme,
|
||||
field,
|
||||
EditorView.updateListener.of((update) => {
|
||||
if (update.docChanged) {
|
||||
this.report();
|
||||
}
|
||||
}),
|
||||
],
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* The chunks' live ranges and states. A chunk is open while its text is
|
||||
* still the base's, taken from a side while it equals that side's, and
|
||||
* edited otherwise; so undo and redo need no bookkeeping.
|
||||
*/
|
||||
get chunks(): readonly Live[] {
|
||||
const state = this.resultView.state;
|
||||
return state.field(this.field).map((range, i) => {
|
||||
const text = state.doc.sliceString(range.from, range.to);
|
||||
const chunk = this.layout.chunks[i];
|
||||
const kind: ChunkState =
|
||||
text === this.bases[i] ? "open" : text === chunk?.ours ? "ours" : text === chunk?.theirs ? "theirs" : "edited";
|
||||
return { ...range, state: kind };
|
||||
});
|
||||
}
|
||||
|
||||
/** How many chunks are still open. */
|
||||
get open(): number {
|
||||
return this.chunks.filter((c) => c.state === "open").length;
|
||||
}
|
||||
|
||||
/** The result text. */
|
||||
get result(): string {
|
||||
return this.resultView.state.doc.toString();
|
||||
}
|
||||
|
||||
/** Tells the side panes which chunks are open and reports the count. */
|
||||
private report(): void {
|
||||
const flags = this.chunks.map((c) => c.state === "open");
|
||||
for (const view of [this.oursView, this.theirsView]) {
|
||||
const before = view.state.field(this.openField);
|
||||
if (before.length !== flags.length || before.some((f, i) => f !== flags[i])) {
|
||||
view.dispatch({ effects: setOpen.of(flags) });
|
||||
}
|
||||
}
|
||||
this.onChange(this.open);
|
||||
}
|
||||
|
||||
/**
|
||||
* Takes one side's text for a chunk.
|
||||
*
|
||||
* @param index - the chunk.
|
||||
* @param side - which side.
|
||||
*/
|
||||
accept(index: number, side: "ours" | "theirs"): void {
|
||||
const live = this.chunks[index];
|
||||
const chunk = this.layout.chunks[index];
|
||||
if (!live || !chunk) {
|
||||
return;
|
||||
}
|
||||
const insert = side === "ours" ? chunk.ours : chunk.theirs;
|
||||
this.resultView.dispatch({
|
||||
changes: { from: live.from, to: live.to, insert },
|
||||
userEvent: "input.merge",
|
||||
});
|
||||
this.current = index;
|
||||
}
|
||||
|
||||
/**
|
||||
* Takes one side's text for every open chunk, last first so earlier
|
||||
* ranges stay valid.
|
||||
*
|
||||
* @param side - which side.
|
||||
*/
|
||||
acceptAll(side: "ours" | "theirs"): void {
|
||||
const open = this.chunks.map((c, i) => ({ c, i })).filter(({ c }) => c.state === "open");
|
||||
for (const { i } of open.reverse()) {
|
||||
this.accept(i, side);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Takes one side for the chunk navigated to last, else the first open one.
|
||||
*
|
||||
* @param side - which side.
|
||||
*/
|
||||
acceptCurrent(side: "ours" | "theirs"): void {
|
||||
const chunks = this.chunks;
|
||||
const index = chunks[this.current]?.state === "open" ? this.current : chunks.findIndex((c) => c.state === "open");
|
||||
if (index >= 0) {
|
||||
this.accept(index, side);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves to the next or previous open chunk, wrapping.
|
||||
*
|
||||
* @param direction - 1 or -1.
|
||||
* @returns whether there was one.
|
||||
*/
|
||||
go(direction: 1 | -1): boolean {
|
||||
const chunks = this.chunks;
|
||||
const count = chunks.length;
|
||||
for (let step = 1; step <= count; step += 1) {
|
||||
const index = (((this.current < 0 && direction < 0 ? 0 : this.current) + direction * step) % count + count) % count;
|
||||
const live = chunks[index];
|
||||
const chunk = this.layout.chunks[index];
|
||||
if (live?.state === "open" && chunk) {
|
||||
this.current = index;
|
||||
this.resultView.dispatch({
|
||||
selection: { anchor: live.from, head: live.to },
|
||||
effects: EditorView.scrollIntoView(live.from, { y: "center" }),
|
||||
});
|
||||
this.oursView.dispatch({ effects: EditorView.scrollIntoView(Math.min(chunk.oursFrom, this.oursView.state.doc.length), { y: "center" }) });
|
||||
this.theirsView.dispatch({
|
||||
effects: EditorView.scrollIntoView(Math.min(chunk.theirsFrom, this.theirsView.state.doc.length), { y: "center" }),
|
||||
});
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Destroys the three editors. */
|
||||
destroy(): void {
|
||||
this.oursView.destroy();
|
||||
this.resultView.destroy();
|
||||
this.theirsView.destroy();
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue