Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
11 changes: 8 additions & 3 deletions public/git-graph-render.js
Original file line number Diff line number Diff line change
Expand Up @@ -168,6 +168,8 @@ function gitGraphRenderGraphSvg(rows, laneAssignments, opts = {}) {
const rowY = Array.isArray(opts.rowY) && opts.rowY.length === rows.length ? opts.rowY : null;
const yOf = i => (rowY ? rowY[i] : rowHeight / 2 + i * rowHeight);
const height = rowY && opts.height ? opts.height : rows.length * rowHeight;
// A table row's own height: measured rows are taller than rowHeight.
const bendHeight = opts.bendHeight || rowHeight;
const paths = [];
const nodes = [];

Expand All @@ -182,15 +184,18 @@ function gitGraphRenderGraphSvg(rows, laneAssignments, opts = {}) {
// An edge bends into its own lane on the first row, runs straight down,
// and only bends again on the last row if its parent sits in another lane.
// A parent that isn't loaded yet keeps the lane running off the bottom.
// Across an inline Commit Details panel a bend still takes one row's
// height, as everywhere else, and the line runs straight beside the panel.
const via = laneWidth / 2 + (edge.viaLane != null ? edge.viaLane : edge.toLane) * laneWidth;
const targetRow = byHash.get(edge.parentHash);
const loaded = targetRow !== undefined;
const tx = loaded ? laneWidth / 2 + edge.toLane * laneWidth : via;
const ty = loaded ? yOf(targetRow) : height + rowHeight / 2;
const endRow = loaded ? targetRow : rows.length;
const route = endRow - i > 1
? { via, top: yOf(i + 1), bottom: loaded ? yOf(targetRow - 1) : height }
: null;
const span = endRow - i;
const top = Math.min(span > 1 ? yOf(i + 1) : ty, cy + bendHeight);
const bottom = loaded ? Math.max(top, span > 1 ? yOf(targetRow - 1) : top, ty - bendHeight) : height;
const route = span > 1 || ty - cy > bendHeight * 1.5 ? { via, top, bottom } : null;
paths.push(gitGraphEdgePath(cx, cy, tx, ty, color, style, route));
}

Expand Down
7 changes: 7 additions & 0 deletions public/git-graph.css
Original file line number Diff line number Diff line change
Expand Up @@ -321,6 +321,13 @@
padding: 14px 16px 16px;
}

/* The panel sits under its row and leaves the graph column free, so the lanes
run on beside it to the rows below. */
.gg-details-inline {
margin-left: var(--gg-graph-width, 60px);
border-bottom: 1px solid rgba(255,255,255,0.07);
}

.gg-details-close {
position: absolute;
top: 8px;
Expand Down
86 changes: 57 additions & 29 deletions public/project-git-graph-view.js
Original file line number Diff line number Diff line change
Expand Up @@ -411,18 +411,18 @@ function gitGraphPaint(project, state, body, opts = {}) {
gitGraphWireFindWidget(project, state, body);
gitGraphWireHeader(project, state, body);
gitGraphWireRows(project, state, body);
// Before the details: bringing a just-opened panel into view starts from here.
if (prevScrollTop != null) {
const newWrap = body.querySelector('.gg-table-wrap');
if (newWrap) newWrap.scrollTop = prevScrollTop;
}
if (state.detailsData) {
// The inline details markup already came back inside #gg-tbody's own
// innerHTML (gitGraphRowsHtml/gitGraphInlineDetailsHtml), so only the
// event wiring — not a second render — is needed here.
const inline = body.querySelector('#gg-details-inline');
if (inline) { gitGraphWireDetailsPanel(project, state, body, inline); gitGraphMaybeAutoCenterDetails(state, inline); }
}

if (prevScrollTop != null) {
const newWrap = body.querySelector('.gg-table-wrap');
if (newWrap) newWrap.scrollTop = prevScrollTop;
}
}

function gitGraphRepoPickerHtml(repos, active) {
Expand Down Expand Up @@ -642,11 +642,22 @@ function gitGraphWireHeader(project, state, body) {

// --- Rows ---

/** The inline Commit Details open right under the row they belong to: the
* commit's own row, or for a comparison the row clicked first. Only when that
* row is no longer loaded do they fall to the end of the list. */
function gitGraphRowsHtml(state) {
if (!state.rows.length) return '<div class="gg-empty-row">No commits yet.</div>';
const showCols = { date: state.columns.date, author: state.columns.author, commit: state.columns.commit };
return state.rows.map((row, index) => gitGraphRowHtml(row, state, showCols, index)).join('') +
(state.detailsData ? gitGraphInlineDetailsHtml(state) : '');
const data = state.detailsData;
const anchor = data ? (data.mode === 'compare' ? state.selectedHash : data.hash) : null;
let placed = false;
const html = state.rows.map((row, index) => {
const rowHtml = gitGraphRowHtml(row, state, showCols, index);
if (!data || placed || row.hash !== anchor) return rowHtml;
placed = true;
return rowHtml + gitGraphInlineDetailsHtml(state);
}).join('');
return html + (data && !placed ? gitGraphInlineDetailsHtml(state) : '');
}

function gitGraphRowHtml(row, state, showCols, index) {
Expand Down Expand Up @@ -682,13 +693,15 @@ function gitGraphWireRows(project, state, body) {
// (every row repeating every other row's paths/circles) was O(rows²)
// DOM nodes; this is O(rows).
const rowY = [];
let rowHeight = 0;
tbody.querySelectorAll('.gg-row[data-row-index]').forEach((el) => {
rowY[Number(el.dataset.rowIndex)] = el.offsetTop + el.offsetHeight / 2;
rowHeight = rowHeight || el.offsetHeight;
});
const measured = rowY.length === state.rows.length && rowY.some(y => y > 0);
const svg = gitGraphRenderGraphSvg(state.rows, state.layout, {
style: state.graphStyle, uncommittedChangesStyle: state.uncommittedChangesStyle,
rowY: measured ? rowY : null, height: measured ? tbody.scrollHeight : null,
rowY: measured ? rowY : null, height: measured ? tbody.scrollHeight : null, bendHeight: measured ? rowHeight : null,
});
const clip = document.createElement('div');
clip.className = 'gg-graph-clip'; // decorative only — clicks/right-clicks fall through to the row underneath
Expand Down Expand Up @@ -796,7 +809,7 @@ function gitGraphOpenDetails(project, state, body, row) {
state.detailsLoading = true;
state.detailsData = { mode: 'single', hash: row.hash, kind: row.kind };
state.detailsJustOpened = true;
gitGraphPaint(project, state, body);
gitGraphPaintDetails(project, state, body);
const fetch = row.kind === 'uncommitted'
? gitGraphApi('getGitGraphCompareDetail', project.id, repo.path, state.headHash, null)
: gitGraphApi('getGitGraphCommitDetail', project.id, repo.path, row.hash);
Expand All @@ -808,7 +821,7 @@ function gitGraphOpenDetails(project, state, body, row) {
} else {
state.detailsData = { mode: 'single', hash: row.hash, kind: row.kind, error: (result && result.error) || 'Could not load commit details.' };
}
gitGraphPaint(project, state, body);
gitGraphPaintDetails(project, state, body);
});
}

Expand All @@ -818,41 +831,56 @@ function gitGraphOpenComparison(project, state, body, fromHash, toHash) {
state.detailsLoading = true;
state.detailsData = { mode: 'compare', fromHash, toHash };
state.detailsJustOpened = true;
gitGraphPaint(project, state, body);
gitGraphPaintDetails(project, state, body);
const toArg = toHash === '#uncommitted' ? null : toHash;
gitGraphApi('getGitGraphCompareDetail', project.id, repo.path, fromHash === '#uncommitted' ? toHash : fromHash, fromHash === '#uncommitted' ? null : toArg)
.then((result) => {
if (request !== state.detailsRequest) return;
state.detailsLoading = false;
if (result && result.ok) state.detailsData = { mode: 'compare', fromHash, toHash, files: result.files || [] };
else state.detailsData = { mode: 'compare', fromHash, toHash, error: (result && result.error) || 'Could not load comparison.' };
gitGraphPaint(project, state, body);
gitGraphPaintDetails(project, state, body);
});
}

/** The panel sits among the rows, so painting it repaints the table: that
* keeps the graph's lines measured around it, and the scroll position where it
* was (a fresh table starts at the top). */
function gitGraphPaintDetails(project, state, body) {
gitGraphPaint(project, state, body, { preserveScroll: true });
}

function gitGraphInlineDetailsHtml(state) {
return `<div class="gg-details gg-details-inline" id="gg-details-inline">${gitGraphDetailsBodyHtml(state)}</div>`;
}

function gitGraphRenderDetailsPanel(project, state, body) {
const container = body.querySelector('#gg-details-inline');
if (!container) return;
container.innerHTML = gitGraphDetailsBodyHtml(state);
gitGraphWireDetailsPanel(project, state, body, container);
}

/** Scrolls the panel into view exactly once per open — the moment it opens,
* not on every subsequent repaint of an already-open panel.
* `state.detailsJustOpened` is set by gitGraphOpenDetails/OpenComparison and
* cleared the first time this runs *with the real content loaded*. The
* request's first paint (still `detailsLoading`) shows only the tiny
* "Loading…" placeholder, so centering on it would land short of where the
* eventual, much taller panel actually ends up — wait for the repaint that
* carries the real commit/diff content before centering and clearing it. */
// A new height (Tree/List, a folder folded) moves every row below the panel.
gitGraphPaintDetails(project, state, body);
}

/** Brings the panel into view exactly once per open, not on every later
* repaint of an already-open panel: `state.detailsJustOpened` is set by
* gitGraphOpenDetails/OpenComparison and cleared the first time this runs
* *with the real content loaded*. The request's first paint (still
* `detailsLoading`) shows only the tiny "Loading…" placeholder, so centering
* on it would land short of where the eventual, much taller panel ends up.
* The clicked row and its panel are centered in the table, or the row goes to
* the top if they are taller than the table. Only the table scrolls, never
* the tab around it. */
function gitGraphMaybeAutoCenterDetails(state, container) {
if (!state.detailsJustOpened || state.detailsLoading) return;
state.detailsJustOpened = false;
if (container && typeof container.scrollIntoView === 'function') container.scrollIntoView({ block: 'center' });
const wrap = container && typeof container.closest === 'function' ? container.closest('.gg-table-wrap') : null;
if (!wrap) return;
const head = wrap.querySelector('.gg-thead');
const headHeight = head ? head.offsetHeight : 0;
const origin = wrap.getBoundingClientRect().top - wrap.scrollTop;
const row = container.previousElementSibling;
const top = (row && row.classList && row.classList.contains('gg-row') ? row : container).getBoundingClientRect().top - origin;
const bottom = container.getBoundingClientRect().bottom - origin;
const room = wrap.clientHeight - headHeight - (bottom - top);
wrap.scrollTop = Math.max(0, top - headHeight - Math.max(0, room / 2));
}

function gitGraphDetailsBodyHtml(state) {
Expand Down Expand Up @@ -981,7 +1009,7 @@ function gitGraphCloseDetails(project, state, body) {
state.detailsData = null;
state.selectedHash = null;
state.compareHash = null;
gitGraphPaint(project, state, body);
gitGraphPaintDetails(project, state, body);
}

function gitGraphOpenFileDiff(project, state, body, repo, filePath, opts = {}) {
Expand Down Expand Up @@ -1236,7 +1264,7 @@ if (typeof module !== 'undefined' && module.exports) {
gitGraphLoadGraph, gitGraphLoadRepositories, gitGraphPaint, gitGraphApi, renderProjectGitGraphTab,
gitGraphSingleCommitHeaderHtml, gitGraphLinkifyBody, gitGraphFileRowHtml, gitGraphFileListHtml,
gitGraphOpenDetails, gitGraphOpenComparison, gitGraphCloseDetails,
gitGraphMaybeAutoCenterDetails, gitGraphIsAncestor, gitGraphHandleRowClick, gitGraphBindKeyboard,
gitGraphMaybeAutoCenterDetails, gitGraphRowsHtml, gitGraphIsAncestor, gitGraphHandleRowClick, gitGraphBindKeyboard,
gitGraphSameBranchNeighbor, gitGraphAlternateBranchNeighbor, gitGraphMoveDetailsFocus,
gitGraphSameStringSet, gitGraphRepoList, gitGraphEnsureWatcherBound,
};
Expand Down
117 changes: 117 additions & 0 deletions test/project-git-graph-view.test.js
Original file line number Diff line number Diff line change
Expand Up @@ -786,3 +786,120 @@ test('gitGraphEnsureWatcherBound binds once and repaints into the current Git Hi
delete require.cache[modulePath];
}
});

// === Inline Commit Details open under the clicked row and stay in view ===

function inlineDetailsState(id) {
const state = view.gitGraphState(id);
state.repositories = [{ path: '/repo', git: true }];
state.selectedRepo = '/repo';
state.rows = [
{ hash: 'c3', kind: 'commit', parents: ['c2'], subject: 'third' },
{ hash: 'c2', kind: 'commit', parents: ['c1'], subject: 'second' },
{ hash: 'c1', kind: 'commit', parents: [], subject: 'first' },
];
state.layout = state.rows.map(() => ({ lane: 0, colorIndex: 0, edges: [] }));
return state;
}

/** Index of each row and of the inline panel in the rows markup. */
function inlineOrder(html) {
return [...html.matchAll(/data-gg-hash="(c\d)" data-row-index|id="gg-details-inline"/g)].map(m => m[1] || 'details');
}

test('the inline Commit Details sit right under the clicked row, not after the last loaded one', () => {
const state = inlineDetailsState('proj-inline-1');
state.selectedHash = 'c2';
state.detailsData = { mode: 'single', hash: 'c2', kind: 'commit', commit: null, files: [] };
assert.deepEqual(inlineOrder(view.gitGraphRowsHtml(state)), ['c3', 'c2', 'details', 'c1']);
});

test('a comparison opens under the row clicked first, and a commit no longer loaded still shows its details at the end', () => {
const state = inlineDetailsState('proj-inline-2');
state.selectedHash = 'c3';
state.compareHash = 'c1';
state.detailsData = { mode: 'compare', fromHash: 'c1', toHash: 'c3', files: [] };
assert.deepEqual(inlineOrder(view.gitGraphRowsHtml(state)), ['c3', 'details', 'c2', 'c1']);

state.selectedHash = 'gone';
state.detailsData = { mode: 'single', hash: 'gone', kind: 'commit', commit: null, files: [] };
assert.deepEqual(inlineOrder(view.gitGraphRowsHtml(state)), ['c3', 'c2', 'c1', 'details']);
});

test('opening, loading and closing the inline details never jumps the table back to the top', async () => {
const state = inlineDetailsState('proj-inline-3');
const project = { id: 'proj-inline-3' };
const body = fakeScrollBody();
global.window = { api: { getGitGraphCommitDetail: () => Promise.resolve({ ok: true, commit: { hash: 'c2', parents: ['c1'] }, files: [] }) } };
body.querySelector('.gg-table-wrap').scrollTop = 400;

view.gitGraphOpenDetails(project, state, body, state.rows[1]);
assert.equal(body.querySelector('.gg-table-wrap').scrollTop, 400, 'the loading paint keeps the scroll position');
await new Promise(resolve => setImmediate(resolve));
assert.equal(state.detailsLoading, false);
assert.equal(body.querySelector('.gg-table-wrap').scrollTop, 400, 'the loaded paint keeps the scroll position');

view.gitGraphCloseDetails(project, state, body);
assert.equal(body.querySelector('.gg-table-wrap').scrollTop, 400, 'closing keeps the scroll position');
});

/** A wrap/row/panel trio with fixed geometry, in the wrap's own coordinates. */
function centeringFixture({ scrollTop, clientHeight, headHeight, rowTop, rowHeight, panelHeight }) {
const wrap = {
scrollTop, clientHeight,
getBoundingClientRect: () => ({ top: 100 }),
querySelector: (sel) => (sel === '.gg-thead' ? { offsetHeight: headHeight } : null),
};
const at = (top, height) => () => ({ top: 100 + top - wrap.scrollTop, bottom: 100 + top + height - wrap.scrollTop });
const row = { classList: { contains: (c) => c === 'gg-row' }, getBoundingClientRect: at(rowTop, rowHeight) };
const panel = {
previousElementSibling: row,
closest: (sel) => (sel === '.gg-table-wrap' ? wrap : null),
getBoundingClientRect: at(rowTop + rowHeight, panelHeight),
};
return { wrap, panel };
}

test('auto-center waits for the loaded details, then centers the row and its panel inside the table only', () => {
const state = inlineDetailsState('proj-inline-4');
const { wrap, panel } = centeringFixture({ scrollTop: 0, clientHeight: 600, headHeight: 30, rowTop: 1000, rowHeight: 24, panelHeight: 200 });
state.detailsJustOpened = true;
state.detailsLoading = true;
view.gitGraphMaybeAutoCenterDetails(state, panel);
assert.equal(wrap.scrollTop, 0, 'a "Loading…" placeholder is not worth scrolling to');
assert.equal(state.detailsJustOpened, true);

state.detailsLoading = false;
view.gitGraphMaybeAutoCenterDetails(state, panel);
// 570px visible under the 30px header, a 224px block: (570 - 224) / 2 = 173 above it.
assert.equal(wrap.scrollTop, 1000 - 30 - 173);
assert.equal(state.detailsJustOpened, false, 'only once per open');

const before = wrap.scrollTop;
view.gitGraphMaybeAutoCenterDetails(state, panel);
assert.equal(wrap.scrollTop, before, 'a later repaint of the same open panel leaves the scroll alone');
});

test('a panel taller than the table puts its row at the top of the table', () => {
const { wrap, panel } = centeringFixture({ scrollTop: 0, clientHeight: 600, headHeight: 30, rowTop: 1000, rowHeight: 24, panelHeight: 900 });
const state = inlineDetailsState('proj-inline-5');
state.detailsJustOpened = true;
view.gitGraphMaybeAutoCenterDetails(state, panel);
assert.equal(wrap.scrollTop, 1000 - 30);
});

test('beside an inline panel a lane change still bends within one row, then the line runs straight', () => {
const rows = [{ hash: 'child', kind: 'commit', parents: ['parent'] }, { hash: 'parent', kind: 'commit', parents: [] }];
const layout = [
{ lane: 1, colorIndex: 0, edges: [{ parentHash: 'parent', toLane: 0, viaLane: 1, style: 'same-lane' }] },
{ lane: 0, colorIndex: 0, edges: [] },
];
const pathOf = (svg) => /<path d="([^"]+)"/.exec(svg)[1];
// Rows 30px tall, side by side: one curve across the row gap, as always.
assert.doesNotMatch(pathOf(render.gitGraphRenderGraphSvg(rows, layout, { rowY: [15, 45], height: 60, bendHeight: 30 })), / L/);

// A 200px panel under the child: straight down its own lane, then one row's bend.
const d = pathOf(render.gitGraphRenderGraphSvg(rows, layout, { rowY: [15, 245], height: 260, bendHeight: 30 }));
const lane = (n) => render.GG_LANE_WIDTH / 2 + n * render.GG_LANE_WIDTH;
assert.equal(d, `M${lane(1)} 15 L${lane(1)} 45 L${lane(1)} 215 C${lane(1)} 230, ${lane(0)} 230, ${lane(0)} 245`);
});
Loading