Factorize logic into helpers and add tests

Author: eliericha

integration/vscode/ada/src/gnatcov.ts

@@ -6,7 +6,7 @@ import * as path from 'path';
 import * as vscode from 'vscode';
 import { CancellationToken } from 'vscode-languageclient';
 import { adaExtState } from './extension';
-import { parallelize, staggerProgress } from './helpers';
+import { getMatchingPrefixes, parallelize, staggerProgress, toPosix } from './helpers';
 
 /**
  * TypeScript types to represent data from GNATcoverage XML reports
@@ -426,44 +426,10 @@ export async function addCoverageData(run: vscode.TestRun, covDir: string) {
                             const localAbsPath = srcUri.fsPath;
                             const posixLocalAbsPath = toPosix(localAbsPath);
 
-                            /**
-                             * Find the longest common prefix between both
-                             * paths by starting to compare the characters
-                             * from the end of each string and iterating
-                             * backwards.
-                             */
-                            let revIndex = 0;
-                            while (
-                                revIndex < posixForeignPath.length &&
-                                revIndex < posixLocalAbsPath.length &&
-                                posixForeignPath[posixForeignPath.length - revIndex] ==
-                                    posixLocalAbsPath[posixLocalAbsPath.length - revIndex]
-                            ) {
-                                revIndex++;
-                            }
-
-                            // Now the index points to the first different
-                            // character, so move it back to the last identical
-                            // character to make the slice operations below
-                            // more natural.
-                            revIndex--;
-
-                            if (
-                                revIndex < posixForeignPath.length &&
-                                revIndex < posixLocalAbsPath.length
-                            ) {
-                                posixLocalPrefix = posixLocalAbsPath.slice(
-                                    0,
-                                    posixLocalAbsPath.length - revIndex,
-                                );
-                                posixForeignPrefix = posixForeignPath.slice(
-                                    0,
-                                    posixForeignPath.length - revIndex,
-                                );
-                            } else {
-                                // Could not find a common prefix so don't
-                                // do anything
-                            }
+                            [posixForeignPrefix, posixLocalPrefix] = getMatchingPrefixes(
+                                posixForeignPath,
+                                posixLocalAbsPath,
+                            );
                         }
 
                         const total = file.metric.find(
@@ -575,27 +541,6 @@ export class GnatcovFileCoverage extends vscode.FileCoverage {
     }
 }
 
-/**
- *
- * @param p - a path
- * @returns a POSIX version of the same path obtained by replacing occurences
- * of `\` with `/`. If the input path was a Windows absolute path, a `/` is
- * prepended to the output to make it also an absolute path.
- */
-function toPosix(p: string) {
-    let posixPath = p.replace(RegExp(`\\${path.win32.sep}`, 'g'), path.posix.sep);
-
-    /**
-     * If it was an absolute path from Windows, we have to
-     * manually make it a POSIX absolute path.
-     */
-    if (path.win32.isAbsolute(p) && !path.posix.isAbsolute(posixPath)) {
-        posixPath = `/${posixPath}`;
-    }
-
-    return posixPath;
-}
-
 export function convertSourceReport(
     data: source_type,
     token?: CancellationToken,

integration/vscode/ada/src/helpers.ts

@@ -644,3 +644,71 @@ export function staggerProgress(
 export function slugify(arg: string): string {
     return arg.replace(/[<>:"/\\|?*]/g, '_');
 }
+/**
+ * @returns the length of the common suffix between the given strings. If there
+ * is no common suffix, the result is `0`.
+ */
+export function getLengthCommonSuffix(str1: string, str2: string): number {
+    /**
+     * Compare characters from the end of each string and iterating backwards.
+     */
+    let len = 0;
+    while (
+        len < str1.length &&
+        len < str2.length &&
+        str1[str1.length - 1 - len] == str2[str2.length - 1 - len]
+    ) {
+        len++;
+    }
+
+    return len;
+}
+
+/**
+ *
+ * @param p - a path
+ * @returns a POSIX version of the same path obtained by replacing occurences
+ * of `\` with `/`. If the input path was a Windows absolute path, a `/` is
+ * prepended to the output to make it also an absolute path.
+ */
+export function toPosix(p: string) {
+    let posixPath = p.replace(RegExp(`\\${path.win32.sep}`, 'g'), path.posix.sep);
+
+    /**
+     * If it was an absolute path from Windows, we have to
+     * manually make it a POSIX absolute path.
+     */
+    if (path.win32.isAbsolute(p) && !path.posix.isAbsolute(posixPath)) {
+        posixPath = `/${posixPath}`;
+    }
+
+    return posixPath;
+}
+
+/**
+ *
+ * @param path1 - a path
+ * @param path2 - another path
+ * @returns if the given paths end with a common suffix, the remaining prefixes
+ * are returned as a tuple by this function. Otherwise, undefined prefixes are
+ * returned.
+ */
+export function getMatchingPrefixes(
+    path1: string,
+    path2: string,
+): [string | undefined, string | undefined] {
+    const lenCommonSuffix = getLengthCommonSuffix(path1, path2);
+
+    let prefix1;
+    let prefix2;
+
+    if (lenCommonSuffix > 0) {
+        prefix1 = path1.slice(0, path1.length - lenCommonSuffix);
+        prefix2 = path2.slice(0, path2.length - lenCommonSuffix);
+    } else {
+        // Could not find a common suffix
+        prefix1 = prefix2 = undefined;
+    }
+
+    return [prefix1, prefix2];
+}

integration/vscode/ada/test/general/helpers.test.ts

@@ -2,10 +2,13 @@ import assert from 'assert';
 import {
     envHasExec,
     findAdaMain,
+    getLengthCommonSuffix,
+    getMatchingPrefixes,
     getSymbols,
     parallelize,
     slugify,
     staggerProgress,
+    toPosix,
     which,
 } from '../../src/helpers';
 import {
@@ -350,3 +353,63 @@ suite('staggerProgress', function () {
         assert.equal(slugify('file<>:"/\\|?*name'), 'file' + '_'.repeat(9) + 'name');
     });
 });
+
+suite('getLengthCommonSuffix', function () {
+    test('empty', function () {
+        assert.equal(getLengthCommonSuffix('', ''), 0);
+    });
+
+    test('one char', function () {
+        assert.equal(getLengthCommonSuffix('a', ''), 0);
+        assert.equal(getLengthCommonSuffix('', 'b'), 0);
+        assert.equal(getLengthCommonSuffix('a', 'a'), 1);
+        assert.equal(getLengthCommonSuffix('a', 'b'), 0);
+    });
+    test('two char', function () {
+        assert.equal(getLengthCommonSuffix('ab', ''), 0);
+        assert.equal(getLengthCommonSuffix('', 'ab'), 0);
+        assert.equal(getLengthCommonSuffix('ab', 'a'), 0);
+        assert.equal(getLengthCommonSuffix('ab', 'b'), 1);
+        assert.equal(getLengthCommonSuffix('ab', 'ab'), 2);
+        assert.equal(getLengthCommonSuffix('ab', 'cd'), 0);
+    });
+    test('more', function () {
+        assert.equal(getLengthCommonSuffix('abcdefg', ''), 0);
+        assert.equal(getLengthCommonSuffix('abcdefg', 'g'), 1);
+        assert.equal(getLengthCommonSuffix('abcdefg', 'x'), 0);
+        assert.equal(getLengthCommonSuffix('abcdefg', 'fg'), 2);
+        assert.equal(getLengthCommonSuffix('abcdefg', 'abcdefg'), 7);
+    });
+});
+
+suite('toPosix', function () {
+    test('Windows paths', function () {
+        assert.equal(toPosix('C:\\some\\path'), '/C:/some/path');
+        assert.equal(toPosix('C:\\some\\path\\'), '/C:/some/path/');
+        assert.equal(toPosix(''), '');
+        assert.equal(toPosix('C:\\'), '/C:/');
+        assert.equal(toPosix('c:\\'), '/c:/');
+        assert.equal(toPosix('a\\relative\\path'), 'a/relative/path');
+    });
+    test('POSIX paths', function () {
+        assert.equal(toPosix('/'), '/');
+        assert.equal(toPosix('/some/path'), '/some/path');
+        assert.equal(toPosix('/some/path/'), '/some/path/');
+        assert.equal(toPosix('a/relative/path'), 'a/relative/path');
+    });
+});
+
+suite('getMatchingPrefixes', function () {
+    test('cases', function () {
+        assert.deepStrictEqual(
+            getMatchingPrefixes('/C:/a/b/common/part.adb', '/other/path/common/part.adb'),
+            ['/C:/a/b', '/other/path'],
+        );
+        assert.deepStrictEqual(
+            getMatchingPrefixes('/C:/a/b/d/e', '/other/path/with/no/common/part'),
+            [undefined, undefined],
+        );
+        assert.deepStrictEqual(getMatchingPrefixes('', ''), [undefined, undefined]);
+        assert.deepStrictEqual(getMatchingPrefixes('a', 'a'), ['', '']);
+    });
+});