@theia/scm 1.48.3 → 1.49.1

package/src/browser/dirty-diff/diff-computer.spec.ts

@@ -42,9 +42,12 @@ describe('dirty-diff-computer', () => {
             ],
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            added: [],
-            modified: [],
-            removed: [0],
+            changes: [
+                {
+                    previousRange: { start: 1, end: 2 },
+                    currentRange: { start: 1, end: 1 },
+                },
+            ],
         });
     });
 
@@ -56,22 +59,29 @@ describe('dirty-diff-computer', () => {
                 sequenceOfN(2),
             );
             expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-                modified: [],
-                removed: [1],
-                added: [],
+                changes: [
+                    {
+                        previousRange: { start: 2, end: 2 + lines },
+                        currentRange: { start: 2, end: 2 },
+                    },
+                ],
             });
         });
     });
 
     it('remove all lines', () => {
+        const numberOfLines = 10;
         const dirtyDiff = computeDirtyDiff(
-            sequenceOfN(10, () => 'TO-BE-REMOVED'),
+            sequenceOfN(numberOfLines, () => 'TO-BE-REMOVED'),
             ['']
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            added: [],
-            modified: [],
-            removed: [0],
+            changes: [
+                {
+                    previousRange: { start: 0, end: numberOfLines },
+                    currentRange: { start: 0, end: 0 },
+                },
+            ],
         });
     });
 
@@ -83,9 +93,12 @@ describe('dirty-diff-computer', () => {
                 sequenceOfN(2),
             );
             expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-                modified: [],
-                removed: [0],
-                added: [],
+                changes: [
+                    {
+                        previousRange: { start: 0, end: lines },
+                        currentRange: { start: 0, end: 0 },
+                    },
+                ],
             });
         });
     });
@@ -96,9 +109,12 @@ describe('dirty-diff-computer', () => {
             const modified = insertIntoArray(previous, 2, ...sequenceOfN(lines, () => 'ADDED LINE'));
             const dirtyDiff = computeDirtyDiff(previous, modified);
             expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-                modified: [],
-                removed: [],
-                added: [{ start: 2, end: 2 + lines - 1 }],
+                changes: [
+                    {
+                        previousRange: { start: 2, end: 2 },
+                        currentRange: { start: 2, end: 2 + lines },
+                    },
+                ],
             });
         });
     });
@@ -111,9 +127,12 @@ describe('dirty-diff-computer', () => {
                     .concat(sequenceOfN(2))
             );
             expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-                modified: [],
-                removed: [],
-                added: [{ start: 0, end: lines - 1 }],
+                changes: [
+                    {
+                        previousRange: { start: 0, end: 0 },
+                        currentRange: { start: 0, end: lines },
+                    },
+                ],
             });
         });
     });
@@ -125,9 +144,12 @@ describe('dirty-diff-computer', () => {
             sequenceOfN(numberOfLines, () => 'ADDED LINE')
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            modified: [],
-            removed: [],
-            added: [{ start: 0, end: numberOfLines - 1 }],
+            changes: [
+                {
+                    previousRange: { start: 0, end: 0 },
+                    currentRange: { start: 0, end: numberOfLines },
+                },
+            ],
         });
     });
 
@@ -145,9 +167,12 @@ describe('dirty-diff-computer', () => {
             ]
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            modified: [],
-            removed: [],
-            added: [{ start: 1, end: 2 }],
+            changes: [
+                {
+                    previousRange: { start: 1, end: 1 },
+                    currentRange: { start: 1, end: 3 },
+                },
+            ],
         });
     });
 
@@ -162,9 +187,12 @@ describe('dirty-diff-computer', () => {
             ]
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            modified: [],
-            removed: [],
-            added: [{ start: 1, end: 1 }],
+            changes: [
+                {
+                    previousRange: { start: 1, end: 1 },
+                    currentRange: { start: 1, end: 2 },
+                },
+            ],
         });
     });
 
@@ -176,9 +204,12 @@ describe('dirty-diff-computer', () => {
                     .concat(new Array(lines).map(() => ''))
             );
             expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-                modified: [],
-                removed: [],
-                added: [{ start: 2, end: 1 + lines }],
+                changes: [
+                    {
+                        previousRange: { start: 2, end: 2 },
+                        currentRange: { start: 2, end: 2 + lines },
+                    },
+                ],
             });
         });
     });
@@ -200,9 +231,12 @@ describe('dirty-diff-computer', () => {
             ]
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            modified: [],
-            removed: [],
-            added: [{ start: 1, end: 5 }],
+            changes: [
+                {
+                    previousRange: { start: 1, end: 1 },
+                    currentRange: { start: 1, end: 6 },
+                },
+            ],
         });
     });
 
@@ -213,9 +247,12 @@ describe('dirty-diff-computer', () => {
                 ['0'].concat(sequenceOfN(lines, () => 'ADDED LINE'))
             );
             expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-                modified: [],
-                removed: [],
-                added: [{ start: 1, end: lines }],
+                changes: [
+                    {
+                        previousRange: { start: 1, end: 1 },
+                        currentRange: { start: 1, end: lines + 1 },
+                    },
+                ],
             });
         });
     });
@@ -234,9 +271,12 @@ describe('dirty-diff-computer', () => {
             ]
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            removed: [],
-            added: [],
-            modified: [{ start: 1, end: 1 }],
+            changes: [
+                {
+                    previousRange: { start: 1, end: 2 },
+                    currentRange: { start: 1, end: 2 },
+                },
+            ],
         });
     });
 
@@ -247,9 +287,12 @@ describe('dirty-diff-computer', () => {
             sequenceOfN(numberOfLines, () => 'MODIFIED')
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            removed: [],
-            added: [],
-            modified: [{ start: 0, end: numberOfLines - 1 }],
+            changes: [
+                {
+                    previousRange: { start: 0, end: numberOfLines },
+                    currentRange: { start: 0, end: numberOfLines },
+                },
+            ],
         });
     });
 
@@ -268,9 +311,12 @@ describe('dirty-diff-computer', () => {
             ]
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            removed: [],
-            added: [],
-            modified: [{ start: 1, end: 2 }],
+            changes: [
+                {
+                    previousRange: { start: 1, end: 4 },
+                    currentRange: { start: 1, end: 3 },
+                },
+            ],
         });
     });
 
@@ -305,9 +351,20 @@ describe('dirty-diff-computer', () => {
             ]
         );
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            removed: [3],
-            added: [{ start: 10, end: 11 }],
-            modified: [{ start: 0, end: 0 }],
+            changes: [
+                {
+                    previousRange: { start: 0, end: 1 },
+                    currentRange: { start: 0, end: 1 },
+                },
+                {
+                    previousRange: { start: 4, end: 5 },
+                    currentRange: { start: 4, end: 4 },
+                },
+                {
+                    previousRange: { start: 11, end: 11 },
+                    currentRange: { start: 10, end: 12 },
+                },
+            ],
         });
     });
 
@@ -340,9 +397,20 @@ describe('dirty-diff-computer', () => {
                 ''
             ]);
         expect(dirtyDiff).to.be.deep.equal(<DirtyDiff>{
-            removed: [11],
-            added: [{ start: 5, end: 5 }, { start: 9, end: 9 }],
-            modified: [],
+            changes: [
+                {
+                    previousRange: { start: 5, end: 5 },
+                    currentRange: { start: 5, end: 6 },
+                },
+                {
+                    previousRange: { start: 8, end: 8 },
+                    currentRange: { start: 9, end: 10 },
+                },
+                {
+                    previousRange: { start: 9, end: 10 },
+                    currentRange: { start: 12, end: 12 },
+                },
+            ],
         });
     });
 

package/src/browser/dirty-diff/diff-computer.ts

@@ -16,6 +16,7 @@
 
 import * as jsdiff from 'diff';
 import { ContentLinesArrayLike } from './content-lines';
+import { Position, Range, uinteger } from '@theia/core/shared/vscode-languageserver-protocol';
 
 export class DiffComputer {
 
@@ -25,52 +26,52 @@ export class DiffComputer {
     }
 
     computeDirtyDiff(previous: ContentLinesArrayLike, current: ContentLinesArrayLike): DirtyDiff {
-        const added: LineRange[] = [];
-        const removed: number[] = [];
-        const modified: LineRange[] = [];
-        const changes = this.computeDiff(previous, current);
-        let lastLine = -1;
-        for (let i = 0; i < changes.length; i++) {
-            const change = changes[i];
-            const next = changes[i + 1];
+        const changes: Change[] = [];
+        const diffResult = this.computeDiff(previous, current);
+        let currentRevisionLine = -1;
+        let previousRevisionLine = -1;
+        for (let i = 0; i < diffResult.length; i++) {
+            const change = diffResult[i];
+            const next = diffResult[i + 1];
             if (change.added) {
                 // case: addition
-                const start = lastLine + 1;
-                const end = lastLine + change.count!;
-                added.push(<LineRange>{ start, end });
-                lastLine = end;
+                changes.push({ previousRange: LineRange.createEmptyLineRange(previousRevisionLine + 1), currentRange: toLineRange(change) });
+                currentRevisionLine += change.count!;
             } else if (change.removed && next && next.added) {
                 const isFirstChange = i === 0;
-                const isLastChange = i === changes.length - 2;
+                const isLastChange = i === diffResult.length - 2;
                 const isNextEmptyLine = next.value.length > 0 && current[next.value[0]].length === 0;
                 const isPrevEmptyLine = change.value.length > 0 && previous[change.value[0]].length === 0;
 
                 if (isFirstChange && isNextEmptyLine) {
                     // special case: removing at the beginning
-                    removed.push(0);
+                    changes.push({ previousRange: toLineRange(change), currentRange: LineRange.createEmptyLineRange(0) });
+                    previousRevisionLine += change.count!;
                 } else if (isFirstChange && isPrevEmptyLine) {
                     // special case: adding at the beginning
-                    const start = 0;
-                    const end = next.count! - 1;
-                    added.push(<LineRange>{ start, end });
-                    lastLine = end;
+                    changes.push({ previousRange: LineRange.createEmptyLineRange(0), currentRange: toLineRange(next) });
+                    currentRevisionLine += next.count!;
                 } else if (isLastChange && isNextEmptyLine) {
-                    removed.push(lastLine + 1 /* = empty line */);
+                    changes.push({ previousRange: toLineRange(change), currentRange: LineRange.createEmptyLineRange(currentRevisionLine + 2) });
+                    previousRevisionLine += change.count!;
                 } else {
                     // default case is a modification
-                    const start = lastLine + 1;
-                    const end = lastLine + next.count!;
-                    modified.push(<LineRange>{ start, end });
-                    lastLine = end;
+                    changes.push({ previousRange: toLineRange(change), currentRange: toLineRange(next) });
+                    currentRevisionLine += next.count!;
+                    previousRevisionLine += change.count!;
                 }
                 i++; // consume next eagerly
             } else if (change.removed && !(next && next.added)) {
-                removed.push(Math.max(0, lastLine));
+                // case: removal
+                changes.push({ previousRange: toLineRange(change), currentRange: LineRange.createEmptyLineRange(currentRevisionLine + 1) });
+                previousRevisionLine += change.count!;
             } else {
-                lastLine += change.count!;
+                // case: unchanged region
+                currentRevisionLine += change.count!;
+                previousRevisionLine += change.count!;
             }
         }
-        return <DirtyDiff>{ added, removed, modified };
+        return { changes };
     }
 
 }
@@ -101,6 +102,11 @@ function diffArrays(oldArr: ContentLinesArrayLike, newArr: ContentLinesArrayLike
     return arrayDiff.diff(oldArr as any, newArr as any) as any;
 }
 
+function toLineRange({ value }: DiffResult): LineRange {
+    const [start, end] = value;
+    return LineRange.create(start, end + 1);
+}
+
 export interface DiffResult {
     value: [number, number];
     count?: number;
@@ -109,21 +115,63 @@ export interface DiffResult {
 }
 
 export interface DirtyDiff {
-    /**
-     * Lines added by comparison to previous revision.
-     */
-    readonly added: LineRange[];
-    /**
-     * Lines, after which lines were removed by comparison to previous revision.
-     */
-    readonly removed: number[];
-    /**
-     * Lines modified by comparison to previous revision.
-     */
-    readonly modified: LineRange[];
+    readonly changes: readonly Change[];
+}
+
+export interface Change {
+    readonly previousRange: LineRange;
+    readonly currentRange: LineRange;
+}
+
+export namespace Change {
+    export function isAddition(change: Change): boolean {
+        return LineRange.isEmpty(change.previousRange);
+    }
+    export function isRemoval(change: Change): boolean {
+        return LineRange.isEmpty(change.currentRange);
+    }
+    export function isModification(change: Change): boolean {
+        return !isAddition(change) && !isRemoval(change);
+    }
 }
 
 export interface LineRange {
-    start: number;
-    end: number;
+    readonly start: number;
+    readonly end: number;
+}
+
+export namespace LineRange {
+    export function create(start: number, end: number): LineRange {
+        if (start < 0 || end < 0 || start > end) {
+            throw new Error(`Invalid line range: { start: ${start}, end: ${end} }`);
+        }
+        return { start, end };
+    }
+    export function createSingleLineRange(line: number): LineRange {
+        return create(line, line + 1);
+    }
+    export function createEmptyLineRange(line: number): LineRange {
+        return create(line, line);
+    }
+    export function isEmpty(range: LineRange): boolean {
+        return range.start === range.end;
+    }
+    export function getStartPosition(range: LineRange): Position {
+        if (isEmpty(range)) {
+            return getEndPosition(range);
+        }
+        return Position.create(range.start, 0);
+    }
+    export function getEndPosition(range: LineRange): Position {
+        if (range.end < 1) {
+            return Position.create(0, 0);
+        }
+        return Position.create(range.end - 1, uinteger.MAX_VALUE);
+    }
+    export function toRange(range: LineRange): Range {
+        return Range.create(getStartPosition(range), getEndPosition(range));
+    }
+    export function getLineCount(range: LineRange): number {
+        return range.end - range.start;
+    }
 }

package/src/browser/dirty-diff/dirty-diff-decorator.ts

@@ -16,8 +16,6 @@
 
 import { injectable } from '@theia/core/shared/inversify';
 import {
-    Range,
-    Position,
     EditorDecoration,
     EditorDecorationOptions,
     OverviewRulerLane,
@@ -25,7 +23,8 @@ import {
     TextEditor,
     MinimapPosition
 } from '@theia/editor/lib/browser';
-import { DirtyDiff, LineRange } from './diff-computer';
+import { DirtyDiff, LineRange, Change } from './diff-computer';
+import { URI } from '@theia/core';
 
 export enum DirtyDiffDecorationType {
     AddedLine = 'dirty-diff-added-line',
@@ -84,24 +83,32 @@ const ModifiedLineDecoration = <EditorDecorationOptions>{
     isWholeLine: true
 };
 
+function getEditorDecorationOptions(change: Change): EditorDecorationOptions {
+    if (Change.isAddition(change)) {
+        return AddedLineDecoration;
+    }
+    if (Change.isRemoval(change)) {
+        return RemovedLineDecoration;
+    }
+    return ModifiedLineDecoration;
+}
+
 export interface DirtyDiffUpdate extends DirtyDiff {
     readonly editor: TextEditor;
+    readonly previousRevisionUri?: URI;
 }
 
 @injectable()
 export class DirtyDiffDecorator extends EditorDecorator {
 
     applyDecorations(update: DirtyDiffUpdate): void {
-        const modifications = update.modified.map(range => this.toDeltaDecoration(range, ModifiedLineDecoration));
-        const additions = update.added.map(range => this.toDeltaDecoration(range, AddedLineDecoration));
-        const removals = update.removed.map(line => this.toDeltaDecoration(line, RemovedLineDecoration));
-        const decorations = [...modifications, ...additions, ...removals];
+        const decorations = update.changes.map(change => this.toDeltaDecoration(change));
         this.setDecorations(update.editor, decorations);
     }
 
-    protected toDeltaDecoration(from: LineRange | number, options: EditorDecorationOptions): EditorDecoration {
-        const [start, end] = (typeof from === 'number') ? [from, from] : [from.start, from.end];
-        const range = Range.create(Position.create(start, 0), Position.create(end, 0));
+    protected toDeltaDecoration(change: Change): EditorDecoration {
+        const range = LineRange.toRange(change.currentRange);
+        const options = getEditorDecorationOptions(change);
         return { range, options };
     }
 }

package/src/browser/dirty-diff/dirty-diff-module.ts

@@ -16,9 +16,18 @@
 
 import { interfaces } from '@theia/core/shared/inversify';
 import { DirtyDiffDecorator } from './dirty-diff-decorator';
+import { DirtyDiffNavigator } from './dirty-diff-navigator';
+import { DirtyDiffWidget, DirtyDiffWidgetFactory, DirtyDiffWidgetProps } from './dirty-diff-widget';
 
 import '../../../src/browser/style/dirty-diff.css';
 
 export function bindDirtyDiff(bind: interfaces.Bind): void {
     bind(DirtyDiffDecorator).toSelf().inSingletonScope();
+    bind(DirtyDiffNavigator).toSelf().inSingletonScope();
+    bind(DirtyDiffWidgetFactory).toFactory(({ container }) => props => {
+        const child = container.createChild();
+        child.bind(DirtyDiffWidgetProps).toConstantValue(props);
+        child.bind(DirtyDiffWidget).toSelf();
+        return child.get(DirtyDiffWidget);
+    });
 }