Skip to content

The Unified and Autonomous Development Platform

feat: Show enclosing symbol context in code diffs

Robin Shene09df4c62fa9
diff --git a/e2e-test/tests/diff-symbol-context.spec.js b/e2e-test/tests/diff-symbol-context.spec.js
new file mode 100644
index 0000000000..d6031363e9
--- /dev/null
+++ b/e2e-test/tests/diff-symbol-context.spec.js
@@ -0,0 +1,252 @@
+import { expect, test, admin } from './fixtures.js';
+import { login } from './helpers.js';
+
+async function waitForContext(page, url, text, side) {
+ await page.goto(url);
+ // Indexing completion should populate context on the current page without a reload.
+ await expect(page.locator(side ? `.diff-symbol-hunk .${side}` : '.diff-symbol-hunk')
+ .filter({ hasText: text }).first()).toBeVisible({ timeout: 60000 });
+}
+
+for (const mode of ['UNIFIED', 'SPLIT']) {
+test(`shows independent indexed contexts in ${mode.toLowerCase()} view`, async ({ page, api, baseURL }) => {
+ await page.context().addCookies([{ name: 'onedev.server.diff.viewmode', value: mode, url: baseURL }]);
+ const errors = [];
+ page.on('pageerror', error => errors.push(error.message));
+ const project = await api.createProject();
+ const source = (name, value) => [
+ 'class AccountService {',
+ ` void ${name}() {`,
+ ...Array.from({ length: 60 }, (_, i) => ` check(${i === 4 ? value : i});`),
+ ' }',
+ ' void resetPassword() {',
+ ...Array.from({ length: 60 }, (_, i) => ` reset(${i === 40 ? value : i});`),
+ ' }',
+ '}',
+ ].join('\n');
+ const first = await api.putFile(project, 'AccountService.java', source('validateNewAccount', 500));
+ await login(page, admin.name, admin.password);
+ // Ensure the old revision has been indexed before replacing it on the branch.
+ await waitForContext(page, `${project.name}/~commits/${first.commitHash}`, 'AccountService');
+ await expect(page.locator('.diff-symbol-sticky .old')).toBeHidden();
+ await expect(page.locator('.diff-symbol-hunk .old')).toBeHidden();
+ await expect(page.locator('.diff-symbol-sticky')).toBeHidden();
+ await expect(page.locator('.diff-symbol-hunk .new')).toContainText('AccountService');
+ const second = await api.putFile(project, 'AccountService.java', source('validateImportedAccount', 999));
+ const url = `${project.name}/~commits/${second.commitHash}`;
+ await waitForContext(page, url, 'AccountService', 'common');
+ const diff = page.locator('.blob-text-diff');
+ await expect(diff.locator('.diff-symbol-hunk').first().locator('.symbol-context-label')).toHaveCount(1);
+ await expect(diff.locator('.diff-symbol-hunk .common .symbol-context-name').first()).toHaveText('AccountService');
+ await expect(diff.locator('.diff-symbol-hunk .symbol-context-side')).toHaveCount(0);
+ await expect(diff.locator('.diff-symbol-hunk').last()).toContainText('resetPassword');
+ await expect(diff.locator('.diff-symbol-sticky')).toBeHidden();
+ await page.screenshot({ path: `test-results/diff-symbol-initial-${mode}.png`, fullPage: true });
+
+ // Expand across method boundaries, retaining syntax highlighting and both revisions.
+ await diff.locator('.expander-controls .expand-down').first().click();
+ await expect(diff.locator('tr.code.expanded')).not.toHaveCount(0);
+ await expect(diff.locator('tr.code.syntaxHighlighted')).not.toHaveCount(0);
+ // The hunk header supplies context until it scrolls behind the file header.
+ const scrollHeader = async offset => {
+ await diff.locator('.diff-symbol-hunk').first().evaluate((header, offset) => {
+ const $ = window.jQuery;
+ const parent = $(header).scrollParent();
+ const head = $(header).closest('.blob-diff').children('.head')[0];
+ parent.scrollTop(parent.scrollTop() + header.getBoundingClientRect().bottom
+ - head.getBoundingClientRect().bottom + offset);
+ }, offset);
+ };
+ await scrollHeader(-1);
+ await expect(diff.locator('.diff-symbol-sticky')).toBeHidden();
+ await scrollHeader(1);
+ await expect(diff.locator('.diff-symbol-sticky')).toBeVisible();
+ await scrollHeader(-1);
+ await expect(diff.locator('.diff-symbol-sticky')).toBeHidden();
+ await diff.locator('td.content[data-new="10"]').last().evaluate(cell => {
+ const $ = window.jQuery;
+ const parent = $(cell).scrollParent();
+ const head = $(cell).closest('.blob-diff').children('.head')[0];
+ parent.scrollTop(parent.scrollTop() + cell.getBoundingClientRect().top
+ - head.getBoundingClientRect().bottom + 1);
+ });
+ await expect(diff.locator('.diff-symbol-sticky')).toBeVisible();
+ await expect(diff.locator('.diff-symbol-sticky .old')).toContainText('validateNewAccount');
+ await expect(diff.locator('.diff-symbol-sticky .new')).toContainText('validateImportedAccount');
+
+ if (mode === 'SPLIT') {
+ await expect.poll(() => diff.evaluate(element => {
+ const row = element.querySelector('tr.code');
+ return Math.abs(element.querySelector('.diff-symbol-sticky .new').getBoundingClientRect().left
+ - row.children[row.children.length / 2].getBoundingClientRect().left);
+ })).toBeLessThan(2);
+ }
+ await page.screenshot({ path: `test-results/diff-symbol-context-${mode}.png`, fullPage: true });
+ // Reveal enough trailing context to scroll the second method to the top.
+ await diff.locator('tr.expander').last().locator('.expand-down').click();
+ await expect(diff.locator('td.content[data-new="125"]').last()).toBeAttached();
+ await diff.locator('td.content[data-new="105"]').last().evaluate(cell => {
+ const $ = window.jQuery;
+ const parent = $(cell).scrollParent();
+ const sticky = $(cell).closest('.blob-text-diff').children('.diff-symbol-sticky');
+ parent.scrollTop(parent.scrollTop() + cell.getBoundingClientRect().top
+ - sticky[0].getBoundingClientRect().bottom);
+ });
+ await expect(diff.locator('.diff-symbol-sticky .old')).toContainText('resetPassword');
+ await expect(diff.locator('.diff-symbol-sticky .new')).toBeHidden();
+ await expect(diff.locator('.diff-symbol-sticky .symbol-context-side:visible')).toHaveCount(0);
+ await page.screenshot({ path: `test-results/diff-symbol-scrolled-${mode}.png`, fullPage: true });
+ await page.evaluate(() => document.documentElement.classList.add('dark-mode'));
+ await page.screenshot({ path: `test-results/diff-symbol-dark-${mode}.png`, fullPage: true });
+ await page.evaluate(() => document.documentElement.classList.remove('dark-mode'));
+ // Switching modes replaces the panel through Ajax and must reinstall its context.
+ await page.locator('[data-tippy-content="Diff options"]').click();
+ await page.getByText(mode === 'UNIFIED' ? 'Split view' : 'Unified view', { exact: true }).click();
+ await expect(diff.locator('.diff-symbol-sticky')).toHaveCount(1);
+ await expect(diff.locator('.diff-symbol-sticky')).toHaveClass(mode === 'UNIFIED' ? /split/ : /^(?!.*split).*diff-symbol-sticky/);
+ await expect(diff.locator('.diff-symbol-hunk .common .symbol-context-name').first()).toHaveText('AccountService');
+ const deletion = await api.json('post', `~api/repositories/${project.id}/files/main/AccountService.java`, {
+ data: { '@type': 'FileDeleteRequest', commitMessage: 'Delete context fixture' },
+ });
+ await waitForContext(page, `${project.name}/~commits/${deletion.commitHash}`, 'AccountService');
+ await expect(diff.locator('.diff-symbol-sticky .new')).toBeHidden();
+ await expect(diff.locator('.diff-symbol-hunk .new')).toBeHidden();
+ await expect(diff.locator('.diff-symbol-sticky')).toBeHidden();
+ await expect(diff.locator('.diff-symbol-hunk .old')).toContainText('AccountService');
+ expect(errors).toEqual([]);
+});
+}
+
+test('shows enclosing JavaScript object methods and prototype assignments', async ({ page, api }) => {
+ const project = await api.createProject();
+ const source = [
+ 'var onedev = {};',
+ 'String.prototype.escape = function() {',
+ ' return this;',
+ '};',
+ 'onedev.server = {',
+ ' form: {',
+ ' markDirty: function(form) {',
+ ...Array.from({ length: 60 }, (_, i) => ` form.check(${i});`),
+ ' },',
+ ' markClean() {',
+ ' return true;',
+ ' }',
+ ' }',
+ '};',
+ ].join('\n');
+ const first = await api.putFile(project, 'test.js', source);
+ await login(page, admin.name, admin.password);
+ await waitForContext(page, `${project.name}/~commits/${first.commitHash}`, 'onedev');
+ const second = await api.putFile(project, 'test.js', source.replace('form.check(30)', 'form.check(999)'));
+ await waitForContext(page, `${project.name}/~commits/${second.commitHash}`, 'markDirty');
+ const diff = page.locator('.blob-text-diff');
+ await expect(diff.locator('.diff-symbol-hunk .common')).toHaveText('onedev > server > form > markDirty');
+ await expect(diff.locator('.diff-symbol-sticky')).toBeHidden();
+});
+
+for (const mode of ['UNIFIED', 'SPLIT']) {
+ test(`anchors expanded insertion and deletion contexts to displayed lines in ${mode.toLowerCase()} view`, async ({ page, api, baseURL }) => {
+ await page.context().addCookies([{ name: 'onedev.server.diff.viewmode', value: mode, url: baseURL }]);
+ const project = await api.createProject();
+ const source = [
+ 'class Service {',
+ ...Array.from({ length: 80 }, (_, i) => ` // Class context ${i}`),
+ ' void start() {',
+ ...Array.from({ length: 60 }, (_, i) => ` check(${i});`),
+ ' }',
+ '}',
+ ].join('\n');
+ const first = await api.putFile(project, 'Service.java', source);
+ await login(page, admin.name, admin.password);
+ await waitForContext(page, `${project.name}/~commits/${first.commitHash}`, 'Service', 'new');
+ for (const content of [source.replace(' check(30);\n check(31);\n', ''), source]) {
+ const commit = await api.putFile(project, 'Service.java', content);
+ await waitForContext(page, `${project.name}/~commits/${commit.commitHash}`, 'Service > start', 'common');
+ const diff = page.locator('.blob-text-diff');
+ await expect(diff.locator('.diff-symbol-hunk .symbol-context-label')).toHaveText('Service > start');
+
+ await diff.locator('tr.expander .expand-up').first().click();
+ await expect(diff.locator('tr.code.expanded')).not.toHaveCount(0);
+ await expect(diff.locator('.diff-symbol-hunk .symbol-context-label')).toHaveText('Service');
+ }
+ });
+
+ test(`hides empty context and restores it on scroll in ${mode.toLowerCase()} view`, async ({ page, api, baseURL }) => {
+ await page.context().addCookies([{ name: 'onedev.server.diff.viewmode', value: mode, url: baseURL }]);
+ const project = await api.createProject();
+ const source = [
+ ...Array.from({ length: 70 }, (_, i) => `// Before ${i}`),
+ 'function run() {',
+ ...Array.from({ length: 70 }, (_, i) => ` check(${i});`),
+ '}',
+ ...Array.from({ length: 100 }, (_, i) => `// After ${i}`),
+ ].join('\n');
+ const first = await api.putFile(project, 'context.js', source);
+ await login(page, admin.name, admin.password);
+ const url = `${project.name}/~commits/${first.commitHash}`;
+ // Wait for indexing without requiring a hunk header: this whole-file hunk
+ // starts outside a symbol and should not have one.
+ await expect(async () => {
+ await page.goto(url);
+ await expect(page.locator('.diff-symbol-sticky')).toBeAttached({ timeout: 2000 });
+ }).toPass({ timeout: 60000, intervals: [1000] });
+ const diff = page.locator('.blob-text-diff');
+ const sticky = diff.locator('.diff-symbol-sticky');
+ await expect(sticky).toBeHidden();
+ await expect(diff.locator('.diff-symbol-hunk')).toHaveCount(0);
+
+ const scrollToLine = async line => {
+ await diff.locator(`td.content[data-new="${line}"]`).last().evaluate(cell => {
+ const $ = window.jQuery;
+ const parent = $(cell).scrollParent();
+ const head = $(cell).closest('.blob-diff').children('.head');
+ const top = head[0].getBoundingClientRect().bottom;
+ // Scroll one pixel past the boundary to avoid a fractional rem-sized
+ // remainder of the preceding line at the top of the viewport.
+ parent.scrollTop(parent.scrollTop() + cell.getBoundingClientRect().top - top + 1);
+ });
+ };
+ await scrollToLine(90);
+ await expect(sticky).toBeVisible();
+ await expect(sticky.locator('.old')).toBeHidden();
+ await expect(sticky.locator('.new')).toContainText('run');
+ if (mode === 'SPLIT') {
+ await expect.poll(() => diff.evaluate(element => {
+ const row = element.querySelector('tr.code');
+ return Math.abs(element.querySelector('.diff-symbol-sticky .new').getBoundingClientRect().left
+ - row.children[row.children.length / 2].getBoundingClientRect().left);
+ })).toBeLessThan(2);
+ }
+ await scrollToLine(170);
+ await expect(sticky).toBeHidden();
+ await expect(sticky).toHaveJSProperty('offsetHeight', 0);
+ await scrollToLine(90);
+ await expect(sticky).toBeVisible();
+ await expect(sticky.locator('.new')).toContainText('run');
+
+ // Scope boundaries must settle without the row repeatedly hiding and showing
+ // as its height changes which source line is visible.
+ for (const [line, visible] of [[142, false], [70, true]]) {
+ await scrollToLine(line);
+ await expect(sticky).toBeVisible({ visible });
+ const states = await sticky.evaluate(async element => {
+ const states = [];
+ for (let i = 0; i < 12; i++) {
+ await new Promise(requestAnimationFrame);
+ states.push(element.offsetHeight > 0);
+ }
+ return states;
+ });
+ expect(states).toEqual(Array(12).fill(visible));
+ }
+
+ const second = await api.putFile(project, 'context.js', source
+ .replace('// Before 4', '// Updated before 4')
+ .replace('check(30)', 'check(999)'));
+ await waitForContext(page, `${project.name}/~commits/${second.commitHash}`, 'run');
+ // Only the in-function hunk has context. The unscoped change gets no row.
+ await expect(diff.locator('.diff-symbol-hunk')).toHaveCount(1);
+ await expect(diff.locator('.diff-symbol-hunk .symbol-context-label')).toHaveText('run');
+ });
+}
diff --git a/e2e-test/tests/text-diff-expander.spec.js b/e2e-test/tests/text-diff-expander.spec.js
index ecf4c6734b..b366082cb1 100644
--- a/e2e-test/tests/text-diff-expander.spec.js
+++ b/e2e-test/tests/text-diff-expander.spec.js
@@ -12,6 +12,7 @@ test('expands text-diff gaps with directional arrows', async ({ page, api }) =>
const commitUrl = `${project.name}/~commits/${commitHash}`;
await page.goto(commitUrl);
+ await expect(page.locator('.diff-symbol-sticky, .diff-symbol-hunk')).toHaveCount(0);
const expanders = page.locator('tr.expander');
await expect(expanders).toHaveCount(3);
const startRow = expanders.first();
diff --git a/pom.xml b/pom.xml
index 1340893047..3efa8db70e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -681,8 +681,8 @@
</repository>
</repositories>
<properties>
- <commons.version>4.1.3</commons.version>
- <agent.version>3.2.7</agent.version>
+ <commons.version>4.2.0</commons.version>
+ <agent.version>3.2.8</agent.version>
<slf4j.version>2.0.9</slf4j.version>
<logback.version>1.4.14</logback.version>
<antlr.version>4.7.2</antlr.version>
diff --git a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/BlobTextDiffPanel.java b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/BlobTextDiffPanel.java
index 0376155436..bdac22576f 100644
--- a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/BlobTextDiffPanel.java
+++ b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/BlobTextDiffPanel.java
@@ -18,8 +18,10 @@ import javax.inject.Inject;
import org.apache.commons.lang3.Strings;
import org.apache.wicket.Component;
+import org.apache.wicket.MetaDataKey;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.behavior.AttributeAppender;
+import org.apache.wicket.core.request.handler.IPartialPageRequestHandler;
import org.apache.wicket.markup.head.IHeaderResponse;
import org.apache.wicket.markup.head.JavaScriptHeaderItem;
import org.apache.wicket.markup.head.OnDomReadyHeaderItem;
@@ -41,6 +43,7 @@ import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.base.Preconditions;
import com.ibm.icu.text.SpoofChecker;
+import io.onedev.commons.jsymbol.SymbolExtractorRegistry;
import io.onedev.commons.utils.LinearRange;
import io.onedev.commons.utils.PlanarRange;
import io.onedev.server.ai.ChatTool;
@@ -56,6 +59,7 @@ import io.onedev.server.git.service.GitService;
import io.onedev.server.model.CodeComment;
import io.onedev.server.model.Project;
import io.onedev.server.model.PullRequest;
+import io.onedev.server.search.code.CodeSearchService;
import io.onedev.server.search.code.hit.QueryHit;
import io.onedev.server.security.SecurityUtils;
import io.onedev.server.service.CodeCommentService;
@@ -84,6 +88,48 @@ import io.onedev.server.web.util.DiffPlanarRange;
public class BlobTextDiffPanel extends Panel implements ChatToolAware {
+ private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(BlobTextDiffPanel.class);
+
+ private static final MetaDataKey<Map<String, List<List<Object>>>> SYMBOL_CONTEXT_CACHE = new MetaDataKey<>() {};
+
+ @Inject
+ private CodeSearchService codeSearchService;
+
+ private List<List<Object>> getSymbolContext(boolean old) {
+ var ident = old ? change.getOldBlobIdent() : change.getNewBlobIdent();
+ if (ident.path == null || SymbolExtractorRegistry.getExtractor(ident.path) == null
+ || old && (change.getType() == ChangeType.ADD || change.getType() == ChangeType.COPY)
+ || !old && change.getType() == ChangeType.DELETE)
+ return List.of();
+ var cache = RequestCycle.get().getMetaData(SYMBOL_CONTEXT_CACHE);
+ if (cache == null) {
+ cache = new HashMap<>();
+ RequestCycle.get().setMetaData(SYMBOL_CONTEXT_CACHE, cache);
+ }
+ var blob = old ? change.getOldBlob() : change.getNewBlob();
+ var key = change.getProject().getId() + ":" + blob.getBlobId().name() + ":" + ident.path;
+ return cache.computeIfAbsent(key, it -> {
+ try {
+ var symbols = codeSearchService.getSymbols(change.getProject(), blob.getBlobId(), ident.path);
+ return DiffSymbolContext.build(symbols, blob.getText().getLines().size());
+ } catch (Exception e) {
+ logger.debug("Unable to load diff symbol context for {}", ident.path, e);
+ return List.of();
+ }
+ });
+ }
+
+ private String getSymbolContextJson() {
+ return convertToJson(Map.of("old", getSymbolContext(true), "new", getSymbolContext(false))).replace("<", "\\u003c");
+ }
+
+ public void refreshSymbolContext(IPartialPageRequestHandler handler) {
+ // Update only the labels so expanded lines, selections and comments stay intact.
+ handler.appendJavaScript(String.format("onedev.server.diffSymbolContext.init($('#%s'), %s, %s);",
+ getMarkupId(), getSymbolContextJson(),
+ convertToJson(Map.of("old-context", _T("Old"), "new-context", _T("New")))));
+ }
+
@Inject
private SettingService settingService;
@@ -491,6 +537,8 @@ public class BlobTextDiffPanel extends Panel implements ChatToolAware {
explicit("param6"), explicit("param7"), explicit("param8"));
var translations = new HashMap<String, String>();
+ translations.put("old-context", _T("Old"));
+ translations.put("new-context", _T("New"));
translations.put("unable-to-comment", _T("Unable to comment"));
translations.put("perma-link", _T("Permanent link of this selection"));
translations.put("copy-to-clipboard", _T("Copy selected text to clipboard"));
@@ -511,7 +559,7 @@ public class BlobTextDiffPanel extends Panel implements ChatToolAware {
translations.put("add-problem-comment", _T("Add comment"));
var jsonOfMarkRange = convertToJson(markRange);
- String script = String.format("onedev.server.blobTextDiff.onDomReady('%s', '%s', '%s', '%s', '%s', '%s', %s, %s, %s, %s, %s, %s, %s);",
+ String script = String.format("onedev.server.blobTextDiff.onDomReady('%s', '%s', '%s', '%s', '%s', '%s', %s, %s, %s, %s, %s, %s, %s, %s);",
getMarkupId(), symbolTooltip.getMarkupId(),
change.getOldBlobIdent().revision,
change.getNewBlobIdent().revision,
@@ -520,7 +568,8 @@ public class BlobTextDiffPanel extends Panel implements ChatToolAware {
callback, blameMessageBehavior.getCallback(),
jsonOfMarkRange, convertToJson(openCommentInfo),
convertToJson(annotationInfoModel.getObject()),
- commentContainerId, convertToJson(translations));
+ commentContainerId, convertToJson(translations),
+ getSymbolContextJson());
response.render(OnDomReadyHeaderItem.forScript(script));
diff --git a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/BlobTextDiffResourceReference.java b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/BlobTextDiffResourceReference.java
index b88a51bc52..f66e9d2577 100644
--- a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/BlobTextDiffResourceReference.java
+++ b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/BlobTextDiffResourceReference.java
@@ -6,6 +6,7 @@ import org.apache.wicket.markup.head.CssHeaderItem;
import org.apache.wicket.markup.head.HeaderItem;
import org.apache.wicket.markup.head.JavaScriptHeaderItem;
import org.apache.wicket.request.resource.CssResourceReference;
+import org.apache.wicket.request.resource.JavaScriptResourceReference;
import io.onedev.server.web.asset.clipboard.ClipboardResourceReference;
import io.onedev.server.web.asset.codeproblem.CodeProblemResourceReference;
@@ -28,6 +29,8 @@ public class BlobTextDiffResourceReference extends BaseDependentResourceReferenc
public List<HeaderItem> getDependencies() {
List<HeaderItem> dependencies = super.getDependencies();
dependencies.add(JavaScriptHeaderItem.forReference(new TextDiffResourceReference()));
+ dependencies.add(JavaScriptHeaderItem.forReference(
+ new JavaScriptResourceReference(BlobTextDiffPanel.class, "diff-symbol-context.js")));
dependencies.add(JavaScriptHeaderItem.forReference(new DoneEventsResourceReference()));
dependencies.add(JavaScriptHeaderItem.forReference(new HoverResourceReference()));
dependencies.add(JavaScriptHeaderItem.forReference(new SelectionPopoverResourceReference()));
diff --git a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/DiffSymbolContext.java b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/DiffSymbolContext.java
new file mode 100644
index 0000000000..c346755b34
--- /dev/null
+++ b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/DiffSymbolContext.java
@@ -0,0 +1,98 @@
+package io.onedev.server.web.component.diff.blob.text;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.PriorityQueue;
+import java.util.TreeMap;
+
+import org.jspecify.annotations.Nullable;
+
+import io.onedev.commons.jsymbol.Symbol;
+
+/** Disjoint line ranges, resolved once so browser lookups can use binary search. */
+public class DiffSymbolContext {
+
+ static final int MAX_SYMBOLS = 10000;
+
+ static final long MAX_PROCESSING_NANOS = 100_000_000;
+
+ private static class Scope {
+ int from;
+ int to;
+ int depth;
+ int order;
+ String label;
+ }
+
+ /** Returns [first line, exclusive last line, parent > symbol] tuples. */
+ public static List<List<Object>> build(@Nullable List<Symbol> symbols, int lineCount) {
+ if (symbols == null || symbols.size() > MAX_SYMBOLS)
+ return List.of();
+ long started = System.nanoTime();
+ var starts = new TreeMap<Integer, List<Scope>>();
+ var boundaries = new java.util.TreeSet<Integer>();
+ int order = 0;
+ for (var symbol : symbols) {
+ if (System.nanoTime() - started > MAX_PROCESSING_NANOS)
+ return List.of();
+ var range = symbol.getScope();
+ if (range == null || !symbol.isDisplayInOutline() || !symbol.isSearchable())
+ continue;
+ var scope = new Scope();
+ scope.from = Math.max(0, range.getFromRow());
+ scope.to = Math.min(lineCount, range.getToRow()
+ + (range.getToColumn() == 0 && range.getToRow() > range.getFromRow() ? 0 : 1));
+ if (scope.from >= scope.to)
+ continue;
+ var names = new ArrayList<String>();
+ var parent = symbol;
+ while (parent != null && scope.depth < 64) {
+ if (parent.isDisplayInOutline() && parent.isSearchable() && parent.getName() != null)
+ names.add(parent.getName());
+ parent = parent.getParent();
+ scope.depth++;
+ }
+ // Bound malformed/cyclic hierarchies and unusually long generated names.
+ if (parent != null || names.isEmpty())
+ continue;
+ java.util.Collections.reverse(names);
+ scope.label = String.join(" > ", names);
+ if (scope.label.length() > 512)
+ continue;
+ scope.order = order++;
+ starts.computeIfAbsent(scope.from, it -> new ArrayList<>()).add(scope);
+ boundaries.add(scope.from);
+ boundaries.add(scope.to);
+ }
+ var active = new PriorityQueue<>(Comparator.<Scope>comparingInt(it -> it.to - it.from)
+ .thenComparingInt(it -> -it.depth).thenComparingInt(it -> it.order));
+ var result = new ArrayList<List<Object>>();
+ Integer previous = null;
+ String label = null;
+ int labelCharacters = 0;
+ for (int line : boundaries) {
+ if (System.nanoTime() - started > MAX_PROCESSING_NANOS)
+ return List.of();
+ if (previous != null && label != null) {
+ var last = result.isEmpty() ? null : result.get(result.size() - 1);
+ if (last != null && last.get(1).equals(previous) && last.get(2).equals(label)) {
+ last.set(1, line);
+ } else {
+ labelCharacters += label.length();
+ if (labelCharacters > 128 * 1024)
+ return List.of();
+ result.add(new ArrayList<>(List.of(previous, line, label)));
+ }
+ }
+ var starting = starts.get(line);
+ if (starting != null)
+ active.addAll(starting);
+ while (!active.isEmpty() && active.peek().to <= line)
+ active.remove();
+ label = active.isEmpty() ? null : active.peek().label;
+ previous = line;
+ }
+ return result;
+ }
+}
diff --git a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/blob-text-diff.css b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/blob-text-diff.css
index ea642624ad..d37c53db1a 100644
--- a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/blob-text-diff.css
+++ b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/blob-text-diff.css
@@ -170,3 +170,73 @@
.blob-text-diff>.text-diff {
table-layout: fixed;
}
+
+.blob-text-diff .symbol-context-label {
+ display: flex;
+ align-items: baseline;
+ gap: 0.6rem;
+ min-width: 0;
+ padding: 0.25rem 0.6rem;
+ font-size: 0.9rem;
+ line-height: 1.5;
+}
+.blob-text-diff .symbol-context-side {
+ flex: none;
+ color: var(--gray);
+ font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
+}
+.blob-text-diff .symbol-context-name {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
+}
+.blob-text-diff>.diff-symbol-sticky {
+ position: sticky;
+ z-index: 4;
+ background: var(--light);
+ border: 1px solid var(--light-gray);
+}
+.blob-text-diff>.diff-symbol-sticky.split {
+ display: flex;
+}
+.blob-text-diff>.diff-symbol-sticky.split>.symbol-context-label {
+ width: 50%;
+ flex: none;
+}
+.blob-text-diff>.diff-symbol-sticky.split>.new {
+ flex: 1;
+ border-left: 1px solid var(--light-gray);
+}
+.blob-text-diff .symbol-context-label.empty,
+.blob-text-diff>.diff-symbol-sticky.empty {
+ display: none;
+}
+.blob-text-diff>.diff-symbol-sticky.split>.symbol-context-label.empty {
+ display: flex;
+ visibility: hidden;
+}
+.blob-text-diff>.diff-symbol-sticky.common>.new,
+.blob-text-diff>.diff-symbol-sticky.common .symbol-context-side {
+ display: none;
+}
+.blob-text-diff>.diff-symbol-sticky.split.common>.old {
+ width: 100%;
+}
+.blob-text-diff>.text-diff>tbody>tr.diff-symbol-hunk>td {
+ padding: 0;
+ background: var(--light);
+ border-top: 1px solid var(--light-gray);
+ border-bottom: 1px solid var(--light-gray);
+}
+.dark-mode .blob-text-diff>.diff-symbol-sticky {
+ background: var(--dark-mode-light-dark);
+ border-color: var(--dark-mode-lighter-dark);
+}
+.dark-mode .blob-text-diff>.diff-symbol-sticky.split>.new,
+.dark-mode .blob-text-diff>.text-diff>tbody>tr.diff-symbol-hunk>td {
+ border-color: var(--dark-mode-lighter-dark);
+}
+.dark-mode .blob-text-diff>.text-diff>tbody>tr.diff-symbol-hunk>td {
+ background: var(--dark-mode-light-dark);
+}
diff --git a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/blob-text-diff.js b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/blob-text-diff.js
index 907a6b87bc..3c40c0ad70 100644
--- a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/blob-text-diff.js
+++ b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/blob-text-diff.js
@@ -2,7 +2,7 @@ onedev.server.blobTextDiff = {
symbolClasses: ".cm-property, .cm-variable, .cm-variable-2, .cm-variable-3, .cm-def, .cm-meta, .cm-string, .cm-tag, .cm-attribute, cm-builtin, cm-qualifier",
onDomReady: function(containerId, symbolTooltipId, oldRev, newRev, oldPath, newPath,
callback, blameMessageCallback, markRange, openComment,
- annotationInfo, commentContainerId, translations) {
+ annotationInfo, commentContainerId, translations, symbolContext) {
onedev.server.blobTextDiff.translations = translations;
var $container = $("#" + containerId);
$container.data("commentContainerId", commentContainerId);
@@ -475,6 +475,7 @@ onedev.server.blobTextDiff = {
}
}
+ onedev.server.diffSymbolContext.init($container, symbolContext, translations);
onedev.server.blobTextDiff.highlightCommentTrigger($container);
if (markRange) {
@@ -498,6 +499,7 @@ onedev.server.blobTextDiff = {
}
onedev.server.blobTextDiff.highlightSyntax($container);
+ onedev.server.diffSymbolContext.update($container);
},
highlightSyntax($container) {
var oldBlobPath = $container.data("oldPath");
@@ -507,12 +509,12 @@ onedev.server.blobTextDiff = {
var $this = $(this);
var $firstCodeTr;
if ($this.is("tbody")) {
- if ($this.children().first().hasClass("code"))
- $firstCodeTr = $this.children().first();
+ if ($this.children().first().is(".code, .diff-symbol-hunk"))
+ $firstCodeTr = $this.children(".code").first();
else
return;
} else if ($this.next().length != 0){
- $firstCodeTr = $this.next();
+ $firstCodeTr = $this.nextAll(".code").first();
} else {
return;
}
@@ -523,7 +525,7 @@ onedev.server.blobTextDiff = {
else
$lastCodeTr = $container.find("tbody>tr:last-child");
- var $codeTrs = $firstCodeTr.nextUntil($lastCodeTr).add($firstCodeTr).add($lastCodeTr);
+ var $codeTrs = $firstCodeTr.nextUntil($lastCodeTr).add($firstCodeTr).add($lastCodeTr).filter(".code");
if ($codeTrs.not(".syntaxHighlighted").length == 0)
return;
@@ -626,6 +628,7 @@ onedev.server.blobTextDiff = {
},
expand: function(containerId, blockIndex, expandedHtml) {
var $container = $("#" + containerId);
+ $container.find("tr.diff-symbol-hunk").remove();
var $expanderTr = $container.find(".expander" + blockIndex);
var $prevTr = $expanderTr.prev();
var $nextTr = $expanderTr.next();
@@ -680,6 +683,7 @@ onedev.server.blobTextDiff = {
processBlames(1);
}
+ onedev.server.diffSymbolContext.refresh($container);
onedev.server.blobTextDiff.initBlameTooltip(containerId, $expandedTrs.find(">td.blame>a.hash"));
onedev.server.blobTextDiff.highlightSyntax($container);
$container.find("td.expander a").each(function() {
diff --git a/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/diff-symbol-context.js b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/diff-symbol-context.js
new file mode 100644
index 0000000000..57bc69881a
--- /dev/null
+++ b/server-core/src/main/java/io/onedev/server/web/component/diff/blob/text/diff-symbol-context.js
@@ -0,0 +1,178 @@
+onedev.server.diffSymbolContext = {
+ lookup: function(ranges, line) {
+ let low = 0;
+ let high = ranges.length;
+ while (low < high) {
+ const middle = (low + high) >>> 1;
+ if (ranges[middle][0] <= line)
+ low = middle + 1;
+ else
+ high = middle;
+ }
+ const range = ranges[low - 1];
+ return range && line < range[1] ? range[2] : "";
+ },
+ label: function(side, text, translations) {
+ const $label = $("<div class='symbol-context-label'>").addClass(side).toggleClass("empty", !text);
+ if (side !== "common")
+ $("<span class='symbol-context-side'>").text(side === "old" ? "-" : "+")
+ .attr("title", translations[side + "-context"]).appendTo($label);
+ $("<span class='symbol-context-name'>").text(text).attr("title", text).appendTo($label);
+ return $label;
+ },
+ init: function($container, ranges, translations) {
+ if (!ranges.old.length && !ranges.new.length)
+ return;
+ const previous = $container.data("symbolContext");
+ if (previous)
+ previous.resizeObserver.disconnect();
+ $container.children(".diff-symbol-sticky").remove();
+ const context = {ranges, translations};
+ $container.data("symbolContext", context);
+ const $sticky = $("<div class='diff-symbol-sticky empty'>").prependTo($container);
+ for (const side of ["old", "new"])
+ $sticky.append(this.label(side, "", translations));
+ this.refresh($container);
+ context.resizeObserver = new ResizeObserver(() => {
+ if (!$container[0].isConnected)
+ context.resizeObserver.disconnect();
+ else
+ this.update($container);
+ });
+ context.resizeObserver.observe($container[0]);
+ if (!this.installed) {
+ this.installed = true;
+ let pending = false;
+ const schedule = () => {
+ if (!pending) {
+ pending = true;
+ requestAnimationFrame(() => {
+ pending = false;
+ $(".blob-text-diff").each((index, element) => this.update($(element)));
+ });
+ }
+ };
+ // One listener for all diffs, including nested scrolling and Ajax replacements.
+ document.addEventListener("scroll", schedule, true);
+ window.addEventListener("resize", schedule);
+ $(document).on("resized", schedule);
+ }
+ },
+ refresh: function($container) {
+ const context = $container.data("symbolContext");
+ if (!context)
+ return;
+ const $table = $container.children("table.text-diff");
+ $table.find("tr.diff-symbol-hunk").remove();
+ const $rows = $table.find("tr.code");
+ const split = $rows.first().children("td.content").length === 2;
+ context.split = split;
+ $container.children(".diff-symbol-sticky").toggleClass("split", split);
+ context.cells = {};
+ context.hunkHeaders = new WeakMap();
+ for (const side of ["old", "new"]) {
+ // Split equal cells carry both line numbers; keep only the corresponding column.
+ context.cells[side] = $rows.children("td.content[data-" + side + "]")
+ .filter((index, cell) => !split || !$(cell).hasClass(side === "old" ? "right" : "left")).toArray();
+ }
+ let hunk = [];
+ const appendHunk = () => {
+ if (!hunk.length)
+ return;
+ const labels = {};
+ for (const side of ["old", "new"]) {
+ const cells = $(hunk).children("td.content[data-" + side + "]")
+ .filter((index, cell) => !split || !$(cell).hasClass(side === "old" ? "right" : "left"));
+ // Describe the code immediately below the header on each side, including
+ // after expansion reveals lines outside the changed symbol's scope.
+ const anchor = cells.first();
+ labels[side] = anchor.length ? this.lookup(context.ranges[side], Number(anchor.attr("data-" + side))) : "";
+ }
+ if (labels.old || labels.new) {
+ const $header = $("<tr class='diff-symbol-hunk'>");
+ const columns = $(hunk[0]).children().length;
+ if (labels.old === labels.new) {
+ $("<td>").attr("colspan", columns).append(this.label("common", labels.old, context.translations)).appendTo($header);
+ } else if (split) {
+ for (const side of ["old", "new"])
+ $("<td>").attr("colspan", columns / 2).append(this.label(side, labels[side], context.translations)).appendTo($header);
+ } else {
+ const $cell = $("<td>").attr("colspan", columns).appendTo($header);
+ for (const side of ["old", "new"])
+ $cell.append(this.label(side, labels[side], context.translations));
+ }
+ $header.insertBefore(hunk[0]);
+ for (const row of hunk)
+ context.hunkHeaders.set(row, $header[0]);
+ }
+ hunk = [];
+ };
+ $table.find("tbody>tr").each((index, row) => {
+ if ($(row).hasClass("expander"))
+ appendHunk();
+ else if ($(row).hasClass("code"))
+ hunk.push(row);
+ });
+ appendHunk();
+ this.update($container);
+ },
+ update: function($container) {
+ const context = $container.data("symbolContext");
+ if (!context || !$container.is(":visible"))
+ return;
+ const bounds = $container[0].getBoundingClientRect();
+ if (bounds.bottom < 0 || bounds.top > window.innerHeight)
+ return;
+ const $sticky = $container.children(".diff-symbol-sticky");
+ const $head = $container.closest(".blob-diff").children(".head");
+ const stickyTop = $head.length ? (parseFloat($head.css("top")) || 0) + $head.outerHeight() : 0;
+ $sticky.css("top", stickyTop);
+ const scrollParent = $container.scrollParent()[0];
+ // Use a stable scroll edge, independent of whether the sticky context is visible.
+ const top = Math.max(bounds.top, $head.length ? $head[0].getBoundingClientRect().bottom : 0,
+ scrollParent && scrollParent.nodeType === 1 ? scrollParent.getBoundingClientRect().top : 0);
+ const bottom = scrollParent && scrollParent.nodeType === 1
+ ? Math.min(window.innerHeight, scrollParent.getBoundingClientRect().bottom) : window.innerHeight;
+ const labels = {};
+ let headerVisible = false;
+ for (const side of ["old", "new"]) {
+ const cells = context.cells[side];
+ let low = 0;
+ let high = cells.length;
+ while (low < high) {
+ const middle = (low + high) >>> 1;
+ if (cells[middle].getBoundingClientRect().bottom <= top)
+ low = middle + 1;
+ else
+ high = middle;
+ }
+ const cell = cells[low];
+ labels[side] = cell && cell.getBoundingClientRect().top < bottom
+ ? this.lookup(context.ranges[side], Number(cell.getAttribute("data-" + side))) : "";
+ if (labels[side]) {
+ const header = context.hunkHeaders.get(cell.parentElement);
+ if (header && header.getBoundingClientRect().bottom > top)
+ headerVisible = true;
+ }
+ }
+ for (const side of ["old", "new"]) {
+ const $label = $sticky.children("." + side).toggleClass("empty", !labels[side]);
+ const $name = $label.children(".symbol-context-name");
+ if ($name.attr("title") !== labels[side])
+ $name.text(labels[side]).attr("title", labels[side]);
+ }
+ const common = labels.old === labels.new;
+ $sticky.toggleClass("common", common);
+ let oldWidth = "";
+ if (context.split && !common && context.cells.new.length) {
+ // Column widths include line numbers, operations and optional blame.
+ const row = $(context.cells.new[0]).parent()[0];
+ const middle = row.children[row.children.length / 2];
+ oldWidth = middle.getBoundingClientRect().left - bounds.left;
+ }
+ $sticky.children(".old").css("width", oldWidth);
+ $sticky.toggleClass("empty", headerVisible || !labels.old && !labels.new);
+ // Overlay the code without moving hunk headers when context appears or disappears.
+ $sticky.css("margin-bottom", $sticky.hasClass("empty") ? 0 : -$sticky.outerHeight());
+ }
+};
diff --git a/server-core/src/main/java/io/onedev/server/web/component/diff/revision/RevisionDiffPanel.java b/server-core/src/main/java/io/onedev/server/web/component/diff/revision/RevisionDiffPanel.java
index 511f37d0fd..cae987e1ed 100644
--- a/server-core/src/main/java/io/onedev/server/web/component/diff/revision/RevisionDiffPanel.java
+++ b/server-core/src/main/java/io/onedev/server/web/component/diff/revision/RevisionDiffPanel.java
@@ -30,6 +30,7 @@ import org.apache.wicket.ajax.form.AjaxFormComponentUpdatingBehavior;
import org.apache.wicket.ajax.markup.html.AjaxLink;
import org.apache.wicket.ajax.markup.html.form.AjaxButton;
import org.apache.wicket.behavior.AttributeAppender;
+import org.apache.wicket.core.request.handler.IPartialPageRequestHandler;
import org.apache.wicket.extensions.markup.html.repeater.tree.ITreeProvider;
import org.apache.wicket.extensions.markup.html.repeater.tree.NestedTree;
import org.apache.wicket.extensions.markup.html.repeater.tree.nested.BranchItem;
@@ -117,6 +118,7 @@ import io.onedev.server.web.component.comment.CommentInput;
import io.onedev.server.web.component.diff.blob.BlobAnnotationSupport;
import io.onedev.server.web.component.diff.blob.BlobDiffPanel;
import io.onedev.server.web.component.diff.blob.BlobDiffReviewSupport;
+import io.onedev.server.web.component.diff.blob.text.BlobTextDiffPanel;
import io.onedev.server.web.component.floating.FloatingPanel;
import io.onedev.server.web.component.markdown.OutdatedSuggestionException;
import io.onedev.server.web.component.markdown.SuggestionSupport;
@@ -396,6 +398,15 @@ public abstract class RevisionDiffPanel extends Panel {
super.onInitialize();
add(new ChangeObserver() {
+
+ @Override
+ public void onObservableChanged(IPartialPageRequestHandler handler, Collection<String> changedObservables) {
+ super.onObservableChanged(handler, changedObservables);
+ RevisionDiffPanel.this.visitChildren(BlobTextDiffPanel.class, (IVisitor<BlobTextDiffPanel, Void>) (panel, visit) -> {
+ if (panel.isVisibleInHierarchy())
+ panel.refreshSymbolContext(handler);
+ });
+ }
@Override
public Collection<String> findObservables() {
diff --git a/server-core/src/test/java/io/onedev/server/search/code/DiffIndexedSymbolsTest.java b/server-core/src/test/java/io/onedev/server/search/code/DiffIndexedSymbolsTest.java
new file mode 100644
index 0000000000..6ad0071978
--- /dev/null
+++ b/server-core/src/test/java/io/onedev/server/search/code/DiffIndexedSymbolsTest.java
@@ -0,0 +1,59 @@
+package io.onedev.server.search.code;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import java.util.ArrayList;
+
+import org.apache.commons.lang3.SerializationUtils;
+import org.apache.lucene.analysis.standard.StandardAnalyzer;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field.Store;
+import org.apache.lucene.document.StoredField;
+import org.apache.lucene.document.StringField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.store.ByteBuffersDirectory;
+import org.eclipse.jgit.lib.ObjectId;
+import org.junit.Test;
+
+import io.onedev.commons.jsymbol.java.JavaExtractor;
+
+public class DiffIndexedSymbolsTest {
+
+ @Test
+ public void readsOnlyMatchingIndexEntriesOnRepeatedReads() throws Exception {
+ var service = new DefaultCodeSearchService();
+ var indexService = new CodeIndexService() {
+ @Override public void indexAsync(Long projectId, ObjectId commitId) { throw new AssertionError("Must not index"); }
+ @Override public boolean isIndexed(Long projectId, ObjectId commitId) { return true; }
+ @Override public String getIndexVersion(io.onedev.commons.jsymbol.SymbolExtractor<io.onedev.commons.jsymbol.Symbol> extractor) { return "current"; }
+ };
+ var field = DefaultCodeSearchService.class.getDeclaredField("indexService");
+ field.setAccessible(true);
+ field.set(service, indexService);
+ var symbols = new ArrayList<>(new JavaExtractor().extract("Example.java", "class Example { void run() {} }"));
+ byte[] bytes = SerializationUtils.serialize(symbols);
+ var blobId = ObjectId.fromString("1111111111111111111111111111111111111111");
+ try (var directory = new ByteBuffersDirectory();
+ var writer = new IndexWriter(directory, new IndexWriterConfig(new StandardAnalyzer()))) {
+ for (String path : new String[] {"Example.java", "stale.java"}) {
+ var document = new Document();
+ document.add(new StringField(FieldConstants.BLOB_HASH.name(), blobId.name(), Store.NO));
+ document.add(new StringField(FieldConstants.BLOB_PATH.name(), path, Store.NO));
+ document.add(new StoredField(FieldConstants.BLOB_INDEX_VERSION.name(), path.equals("stale.java") ? "old" : "current"));
+ document.add(new StoredField(FieldConstants.BLOB_SYMBOL_LIST.name(), bytes));
+ writer.addDocument(document);
+ }
+ try (var reader = DirectoryReader.open(writer)) {
+ var searcher = new IndexSearcher(reader);
+ assertEquals(symbols.size(), service.getSymbols(searcher, blobId, "Example.java").size());
+ assertEquals(symbols.size(), service.getSymbols(searcher, blobId, "Example.java").size());
+ assertNull(service.getSymbols(searcher, blobId, "stale.java"));
+ assertNull(service.getSymbols(searcher, blobId, "missing.java"));
+ }
+ }
+ }
+}
diff --git a/server-core/src/test/java/io/onedev/server/web/component/diff/blob/text/DiffSymbolContextTest.java b/server-core/src/test/java/io/onedev/server/web/component/diff/blob/text/DiffSymbolContextTest.java
new file mode 100644
index 0000000000..cdc9da46c4
--- /dev/null
+++ b/server-core/src/test/java/io/onedev/server/web/component/diff/blob/text/DiffSymbolContextTest.java
@@ -0,0 +1,73 @@
+package io.onedev.server.web.component.diff.blob.text;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import io.onedev.commons.jsymbol.Symbol;
+import io.onedev.commons.jsymbol.java.JavaExtractor;
+import io.onedev.commons.jsymbol.java.symbols.JavaSymbol;
+import io.onedev.commons.utils.PlanarRange;
+
+public class DiffSymbolContextTest {
+
+ @Test
+ public void resolvesNestedScopesAndReturnsToParent() {
+ var symbols = new JavaExtractor().extract("Example.java", "package demo;\nclass Example {\n"
+ + " void first() {\n work();\n }\n void second() {\n work();\n }\n}\n");
+ assertEquals(List.of(List.of(1, 2, "Example"), List.of(2, 5, "Example > first"),
+ List.of(5, 8, "Example > second"), List.of(8, 9, "Example")),
+ DiffSymbolContext.build(new ArrayList<>(symbols), 10));
+ }
+
+ @Test
+ public void handlesOverlappingScopesAndExclusiveEndLines() {
+ var outer = symbol(null, "Outer", 0, 20, 1);
+ var first = symbol(outer, "first", 2, 8, 0);
+ var overlap = symbol(outer, "overlap", 5, 12, 1);
+ assertEquals(List.of(List.of(0, 2, "Outer"), List.of(2, 8, "Outer > first"),
+ List.of(8, 13, "Outer > overlap"), List.of(13, 21, "Outer")),
+ DiffSymbolContext.build(List.of(overlap, first, outer), 21));
+ }
+
+ @Test
+ public void skipsMissingAndOversizedSymbolLists() {
+ assertTrue(DiffSymbolContext.build(null, 100).isEmpty());
+ assertTrue(DiffSymbolContext.build(java.util.Collections.nCopies(DiffSymbolContext.MAX_SYMBOLS + 1,
+ symbol(null, "Generated", 0, 99, 1)), 100).isEmpty());
+ }
+
+ @Test
+ public void boundsDeepHierarchiesAndLabels() {
+ JavaSymbol parent = null;
+ for (int i = 0; i < 65; i++)
+ parent = symbol(parent, "Nested", 0, 100, 1);
+ assertTrue(DiffSymbolContext.build(List.of(parent), 101).isEmpty());
+ assertTrue(DiffSymbolContext.build(List.of(symbol(null, "x".repeat(513), 0, 1, 1)), 2).isEmpty());
+ }
+
+ @Test
+ public void mapsSymbolHeavyFile() {
+ var symbols = new ArrayList<Symbol>();
+ var outer = symbol(null, "Generated", 0, 60000, 1);
+ symbols.add(outer);
+ for (int i = 0; i < 9000; i++)
+ symbols.add(symbol(outer, "m" + i, i * 6 + 1, i * 6 + 3, 1));
+ var ranges = DiffSymbolContext.build(symbols, 60001);
+ // This payload exceeds the display budget and should be omitted, not partially shown.
+ assertTrue(ranges.isEmpty());
+ }
+
+ private JavaSymbol symbol(JavaSymbol parent, String name, int from, int to, int column) {
+ return new JavaSymbol(parent, name, null, new PlanarRange(from, 0, to, column)) {
+ @Override public boolean isLocal() { return false; }
+ @Override public boolean isPrimary() { return true; }
+ @Override public org.apache.wicket.markup.html.image.Image renderIcon(String id) { return null; }
+ @Override public org.apache.wicket.Component render(String id, io.onedev.commons.utils.LinearRange range) { return null; }
+ };
+ }
+}