3212722686

Build Type

push

github

Committed by GitHub

Commit Message

- add `prependedCacheKey` input for letting users to prepend to the cache key. (#161)

Run Details

115 of 202 branches covered (56.93%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 2 files covered. (100.0%)

11 existing lines in 2 files now uncovered.

228 of 296 relevant lines covered (77.03%)

3.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.0

/src/vcpkg-utils.ts

// Copyright (c) 2020-2021-2022 Luca Cappa
// Released under the term specified in file LICENSE.txt
// SPDX short identifier: MIT

import * as path from 'path'
import * as fs from 'fs'
import * as runvcpkglib from '@lukka/run-vcpkg-lib'
import * as baselib from '@lukka/base-lib'
import * as baseutillib from '@lukka/base-util-lib'
import * as cache from '@actions/cache'
import * as vcpkgaction from './vcpkg-action'

export class Utils {

  public static isExactKeyMatch(key: string, cacheKey?: string): boolean {
    if (cacheKey)
      return cacheKey.localeCompare(key, undefined, { sensitivity: "accent" }) === 0;
    else
      return false;
  }

  /**
   * Retrieve the commit id of the Git repository at vcpkgDirectory.
   * Returns [undefined, undefined] when the provided path is not the root of a Git repository.
   * @static
   * @param {baseutillib.BaseUtilLib} baseUtils
   * @param {string} vcpkgDirectory
   * @returns {(Promise<[string | undefined, boolean | undefined]>)}
   * @memberof Utils
   */
  public static async getVcpkgCommitId(baseUtils: baseutillib.BaseUtilLib, vcpkgDirectory: string): Promise<[string | undefined, boolean | undefined]> {
    baseUtils.baseLib.debug(`getVcpkgCommitId()<<`);
    let id = undefined;
    let isSubmodule = undefined;
    const workspaceDir = process.env.GITHUB_WORKSPACE ?? "";
    if (workspaceDir) {
      let fullVcpkgPath = "";
      baseUtils.baseLib.debug(`inputVcpkgPath=${vcpkgDirectory}`);
      if (path.isAbsolute(vcpkgDirectory))
        fullVcpkgPath = path.normalize(path.resolve(vcpkgDirectory));
      else
        fullVcpkgPath = path.normalize(path.resolve(path.join(workspaceDir, vcpkgDirectory)));
      baseUtils.baseLib.debug(`fullVcpkgPath='${fullVcpkgPath}'`);
      const relPath = fullVcpkgPath.replace(workspaceDir, '');
      baseUtils.baseLib.debug(`relPath='${relPath}'`);
      const submodulePath = path.join(workspaceDir, ".git/modules", relPath, "HEAD")
      baseUtils.baseLib.debug(`submodulePath='${submodulePath}'`);
      // Check whether it is a submodule.
      if (fs.existsSync(submodulePath)) {
        id = fs.readFileSync(submodulePath).toString();
        baseUtils.baseLib.debug(`commitId='${id}'`);
        isSubmodule = true;
      } else if (fs.existsSync(path.join(fullVcpkgPath, ".git"))) {
        id = await runvcpkglib.VcpkgRunner.getCommitId(baseUtils, fullVcpkgPath);
        isSubmodule = false;
      }
      id = id?.trim();
    }
    baseUtils.baseLib.debug(`getVcpkgCommitId()>> -> [id=${id}, isSubmodule=${isSubmodule}]`);
    return [id, isSubmodule];
  }

  public static async getVcpkgJsonHash(baseUtil: baseutillib.BaseUtilLib, vcpkgJsonGlob: string, vcpkgJsonIgnores: string[]): Promise<[string | null, string | null, string | null]> {
    try {
      const [vcpkgJsonPath, vcpkgJsonHash] = await baseUtil.getFileHash(vcpkgJsonGlob, vcpkgJsonIgnores);
      if (vcpkgJsonPath) {
        baseUtil.baseLib.info(`Found ${runvcpkglib.VCPKG_JSON} at '${vcpkgJsonPath}', its hash is '${vcpkgJsonHash}''.`);
        const vcpkgConfJsonPath: string = path.join(path.dirname(vcpkgJsonPath), runvcpkglib.VCPKG_CONFIGURATION_JSON);
        let vcpkgConfigurationHash = null;
        if (baseUtil.fileExists(vcpkgConfJsonPath)) {
          vcpkgConfigurationHash = await baseUtil.baseLib.hashFiles(vcpkgConfJsonPath);
          baseUtil.baseLib.info(`Found sibling ${runvcpkglib.VCPKG_CONFIGURATION_JSON} at '${vcpkgConfJsonPath}', its hash is '${vcpkgConfigurationHash}'.`)
        }
        return [vcpkgJsonPath, vcpkgJsonHash, vcpkgConfigurationHash];
      }
    }
    catch (err) {
      if (err instanceof Error) {
        baseUtil.baseLib.warning(err.message);
      }
    }

    baseUtil.baseLib.warning(`Cannot compute hash of vcpkg.json as it was not found (or multiple hits) with glob expression '${vcpkgJsonGlob}'.`);
    return [null, null, null];
  }

  public static async computeCacheKeys(
    baseUtilLib: baseutillib.BaseUtilLib,
    vcpkgJsonHash: string | null,
    vcpkgConfJsonHash: string | null,
    vcpkgDirectory: string,
    userProvidedCommitId: string | null,
    appendedCacheKey: string | null,
    prependedCacheKey: string | null): Promise<baseutillib.KeySet> {
    baseUtilLib.baseLib.debug(`computeCacheKeys()<<`);
    const cacheKeySegments: string[] = [];

    // Add to the first segment of the key the values of env vars ImageOS and ImageVersion if available.
    let firstSegment = prependedCacheKey ? `prependedKey=${prependedCacheKey}-` : "";
    firstSegment += `runnerOS=${process.env['ImageOS'] ? process.env['ImageOS'] : process.platform}`;
    firstSegment += process.env['ImageVersion'] || "";

    const [commitId, isSubmodule] = await Utils.getVcpkgCommitId(baseUtilLib, vcpkgDirectory);
    if (commitId) {
      firstSegment += `-vcpkgGitCommit=${commitId}`;
      if (isSubmodule) {
        baseUtilLib.baseLib.info(`Adding vcpkg submodule Git commit id '${commitId}' to cache key`);
        if (userProvidedCommitId) {
          baseUtilLib.baseLib.warning(`Provided Git commit id is disregarded: '${userProvidedCommitId}'. Please remove it from the inputs.`);
        }
      } else {
        baseUtilLib.baseLib.info(`vcpkg identified at Git commit id '${commitId}', adding it to the cache's key.`);
      }
    } else if (userProvidedCommitId) {
      firstSegment += `-vcpkgGitCommit=${userProvidedCommitId}`;
      baseUtilLib.baseLib.info(`Adding user provided vcpkg's Git commit id '${userProvidedCommitId}' to cache key.`);
    } else {
      baseUtilLib.baseLib.info(`No vcpkg's commit id was provided, does not contribute to the cache's key.`);
    }

    cacheKeySegments.push(firstSegment);

    if (vcpkgJsonHash) {
      let hash = `vcpkgJson=${vcpkgJsonHash}`;
      baseUtilLib.baseLib.info(`Adding hash of ${runvcpkglib.VCPKG_JSON}: '${vcpkgJsonHash}'.`);
      if (vcpkgConfJsonHash) {
        baseUtilLib.baseLib.info(`Adding hash of ${runvcpkglib.VCPKG_CONFIGURATION_JSON}: '${vcpkgConfJsonHash}'.`);
        hash += `-vcpkgConfigurationJson=${vcpkgConfJsonHash}`;
      }
      cacheKeySegments.push(hash);
    }

    if (appendedCacheKey) {
      cacheKeySegments.push(`appendedKey=${appendedCacheKey}`);
    }

    const keyset: baseutillib.KeySet = baseutillib.createKeySet(cacheKeySegments);
    baseUtilLib.baseLib.debug(`computeCacheKeys()>>`);
    return keyset;
  }

  public static async saveCache(baseLib: baselib.BaseLib, doNotCache: boolean, keys: baseutillib.KeySet,
    hitCacheKey: string | null, cachedPaths: string[]): Promise<void> {
    baseLib.debug(`saveCache(doNotCache:${doNotCache},keys:${JSON.stringify(keys)},hitCacheKey:${hitCacheKey},cachedPaths:${cachedPaths})<<`)
    try {
      if (doNotCache) {
        baseLib.info(`Caching is disabled, saving cache is skipped.`);
      } else {
        if (hitCacheKey && Utils.isExactKeyMatch(keys.primary, hitCacheKey)) {
          baseLib.info(`Saving cache is skipped, because cache hit occurred on the cache key '${keys.primary}'.`);
        } else {
          baseLib.info(`Saving a new cache entry, because primary key was missed or a fallback restore key was hit.`);
          const pathsToCache: string[] = cachedPaths;
          baseLib.info(`Caching paths: '${pathsToCache}'`);

          try {
            baseLib.info(`Saving cache with primary key '${keys.primary}' ...`);
            await cache.saveCache(pathsToCache, keys.primary);
          }
          catch (error) {
            if (error instanceof Error) {
              if (error.name === cache.ValidationError.name) {
                throw error;
              } else if (error.name === cache.ReserveCacheError.name) {
                baseLib.info(error.message);
              } else {
                baseLib.warning(error.message);
              }
            }
          }
        }
      }
    } catch (err) {
      baseLib.warning("vcpkg-utils.saveCache() failed!");
      if (err instanceof Error) {
        baseLib.warning(err.name);
        baseLib.warning(err.message);
        if (err?.stack) {
          baseLib.warning(err.stack);
        }
      }
    }

    baseLib.debug(`saveCache()>>`)
  }

  public static addCachedPaths(baseLib: baselib.BaseLib, paths: string | null): void {
    baseLib.debug(`addCachedPaths(${paths})<<`)
    if (paths) {
      baseLib.debug(`Adding cached paths: '${paths}''`);
      let s: string | undefined = baseLib.getState(vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE);
      s = `${s ?? ''};${paths}`;
      baseLib.setState(vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE, s);
      baseLib.debug(`Set ${vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE}=${s}`);
    }
    baseLib.debug(`addCachedPaths()>>`)
  }

  public static getAllCachedPaths(baseLib: baselib.BaseLib, vcpkgRootDir: string): string[] {
    baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<<`);
    let pathsToCache: string[] = [];
    // Hack-ish: ensure that VCPKG_DEFAULT_BINARY_CACHE is always added to the list of cached paths.
    // When this functino is called by the action, the env var contains the binary cache path.
    // When this function is called by the post action, the env var is not defined (but the path is in the "state").
    const binCachePath: string | undefined = process.env[vcpkgaction.VcpkgAction.VCPKG_DEFAULT_BINARY_CACHE];
    if (binCachePath) {
      pathsToCache = pathsToCache.concat([binCachePath]);
    }

    const additionalCachedPaths: string | undefined = baseLib.getState(vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE);
    baseLib.debug(`getState(${vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE}) -> '${additionalCachedPaths}'`);
    if (additionalCachedPaths) {
      pathsToCache = pathsToCache.concat(additionalCachedPaths.split(';'));
    }
    pathsToCache = pathsToCache.concat(runvcpkglib.getOrdinaryCachedPaths(vcpkgRootDir));

    // Remove empty entries.
    pathsToCache = pathsToCache.map(s => s.trim()).filter(Boolean);

    // Remove duplicates.
    const ps = [...new Set(pathsToCache)];

    baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<< -> '${JSON.stringify(ps)}'`);
    return ps;
  }
}

1	// Copyright (c) 2020-2021-2022 Luca Cappa
2	// Released under the term specified in file LICENSE.txt
3	// SPDX short identifier: MIT
4
5	import * as path from 'path'	1✔
6	import * as fs from 'fs'	1✔
7	import * as runvcpkglib from '@lukka/run-vcpkg-lib'	1✔
8	import * as baselib from '@lukka/base-lib'
9	import * as baseutillib from '@lukka/base-util-lib'	1✔
10	import * as cache from '@actions/cache'	1✔
11	import * as vcpkgaction from './vcpkg-action'	1✔
12
13	export class Utils {	1✔
14
15	public static isExactKeyMatch(key: string, cacheKey?: string): boolean {
16	if (cacheKey)	5!
17	return cacheKey.localeCompare(key, undefined, { sensitivity: "accent" }) === 0;	5✔
18	else
19	return false;	×
20	}
21
22	/**
23	* Retrieve the commit id of the Git repository at vcpkgDirectory.
24	* Returns [undefined, undefined] when the provided path is not the root of a Git repository.
25	* @static
26	* @param {baseutillib.BaseUtilLib} baseUtils
27	* @param {string} vcpkgDirectory
28	* @returns {(Promise<[string \| undefined, boolean \| undefined]>)}
29	* @memberof Utils
30	*/
31	public static async getVcpkgCommitId(baseUtils: baseutillib.BaseUtilLib, vcpkgDirectory: string): Promise<[string \| undefined, boolean \| undefined]> {
32	baseUtils.baseLib.debug(`getVcpkgCommitId()<<`);	9✔
33	let id = undefined;	9✔
34	let isSubmodule = undefined;	9✔
35	const workspaceDir = process.env.GITHUB_WORKSPACE ?? "";	9✔
36	if (workspaceDir) {	9✔
37	let fullVcpkgPath = "";	8✔
38	baseUtils.baseLib.debug(`inputVcpkgPath=${vcpkgDirectory}`);	8✔
39	if (path.isAbsolute(vcpkgDirectory))	8!
40	fullVcpkgPath = path.normalize(path.resolve(vcpkgDirectory));	8✔
41	else
42	fullVcpkgPath = path.normalize(path.resolve(path.join(workspaceDir, vcpkgDirectory)));	×
43	baseUtils.baseLib.debug(`fullVcpkgPath='${fullVcpkgPath}'`);	8✔
44	const relPath = fullVcpkgPath.replace(workspaceDir, '');	8✔
45	baseUtils.baseLib.debug(`relPath='${relPath}'`);	8✔
46	const submodulePath = path.join(workspaceDir, ".git/modules", relPath, "HEAD")	8✔
47	baseUtils.baseLib.debug(`submodulePath='${submodulePath}'`);	8✔
48	// Check whether it is a submodule.
49	if (fs.existsSync(submodulePath)) {	8✔
50	id = fs.readFileSync(submodulePath).toString();	1✔
51	baseUtils.baseLib.debug(`commitId='${id}'`);	1✔
52	isSubmodule = true;	1✔
53	} else if (fs.existsSync(path.join(fullVcpkgPath, ".git"))) {	7✔
54	id = await runvcpkglib.VcpkgRunner.getCommitId(baseUtils, fullVcpkgPath);	2✔
55	isSubmodule = false;	2✔
56	}
57	id = id?.trim();	8✔
58	}
59	baseUtils.baseLib.debug(`getVcpkgCommitId()>> -> [id=${id}, isSubmodule=${isSubmodule}]`);	9✔
60	return [id, isSubmodule];	9✔
61	}
62
63	public static async getVcpkgJsonHash(baseUtil: baseutillib.BaseUtilLib, vcpkgJsonGlob: string, vcpkgJsonIgnores: string[]): Promise<[string \| null, string \| null, string \| null]> {
64	try {	5✔
65	const [vcpkgJsonPath, vcpkgJsonHash] = await baseUtil.getFileHash(vcpkgJsonGlob, vcpkgJsonIgnores);	5✔
66	if (vcpkgJsonPath) {	5!
67	baseUtil.baseLib.info(`Found ${runvcpkglib.VCPKG_JSON} at '${vcpkgJsonPath}', its hash is '${vcpkgJsonHash}''.`);	5✔
68	const vcpkgConfJsonPath: string = path.join(path.dirname(vcpkgJsonPath), runvcpkglib.VCPKG_CONFIGURATION_JSON);	5✔
69	let vcpkgConfigurationHash = null;	5✔
70	if (baseUtil.fileExists(vcpkgConfJsonPath)) {	5!
71	vcpkgConfigurationHash = await baseUtil.baseLib.hashFiles(vcpkgConfJsonPath);	×
72	baseUtil.baseLib.info(`Found sibling ${runvcpkglib.VCPKG_CONFIGURATION_JSON} at '${vcpkgConfJsonPath}', its hash is '${vcpkgConfigurationHash}'.`)	×
73	}
74	return [vcpkgJsonPath, vcpkgJsonHash, vcpkgConfigurationHash];	5✔
75	}
76	}
77	catch (err) {
78	if (err instanceof Error) {	×
79	baseUtil.baseLib.warning(err.message);	×
80	}
81	}
82
83	baseUtil.baseLib.warning(`Cannot compute hash of vcpkg.json as it was not found (or multiple hits) with glob expression '${vcpkgJsonGlob}'.`);	×
84	return [null, null, null];	×
85	}
86
87	public static async computeCacheKeys(
88	baseUtilLib: baseutillib.BaseUtilLib,
89	vcpkgJsonHash: string \| null,
90	vcpkgConfJsonHash: string \| null,
91	vcpkgDirectory: string,
92	userProvidedCommitId: string \| null,
93	appendedCacheKey: string \| null,
94	prependedCacheKey: string \| null): Promise<baseutillib.KeySet> {
95	baseUtilLib.baseLib.debug(`computeCacheKeys()<<`);	9✔
96	const cacheKeySegments: string[] = [];	9✔
97
98	// Add to the first segment of the key the values of env vars ImageOS and ImageVersion if available.
99	let firstSegment = prependedCacheKey ? `prependedKey=${prependedCacheKey}-` : "";	9✔
100	firstSegment += `runnerOS=${process.env['ImageOS'] ? process.env['ImageOS'] : process.platform}`;	9!
101	firstSegment += process.env['ImageVersion'] \|\| "";	9!
102
103	const [commitId, isSubmodule] = await Utils.getVcpkgCommitId(baseUtilLib, vcpkgDirectory);	9✔
104	if (commitId) {	9✔
105	firstSegment += `-vcpkgGitCommit=${commitId}`;	4✔
106	if (isSubmodule) {	4✔
107	baseUtilLib.baseLib.info(`Adding vcpkg submodule Git commit id '${commitId}' to cache key`);	2✔
108	if (userProvidedCommitId) {	2✔
109	baseUtilLib.baseLib.warning(`Provided Git commit id is disregarded: '${userProvidedCommitId}'. Please remove it from the inputs.`);	1✔
110	}
111	} else {
112	baseUtilLib.baseLib.info(`vcpkg identified at Git commit id '${commitId}', adding it to the cache's key.`);	2✔
113	}
114	} else if (userProvidedCommitId) {	5✔
115	firstSegment += `-vcpkgGitCommit=${userProvidedCommitId}`;	1✔
116	baseUtilLib.baseLib.info(`Adding user provided vcpkg's Git commit id '${userProvidedCommitId}' to cache key.`);	1✔
117	} else {
118	baseUtilLib.baseLib.info(`No vcpkg's commit id was provided, does not contribute to the cache's key.`);	4✔
119	}
120
121	cacheKeySegments.push(firstSegment);	9✔
122
123	if (vcpkgJsonHash) {	9✔
124	let hash = `vcpkgJson=${vcpkgJsonHash}`;	8✔
125	baseUtilLib.baseLib.info(`Adding hash of ${runvcpkglib.VCPKG_JSON}: '${vcpkgJsonHash}'.`);	8✔
126	if (vcpkgConfJsonHash) {	8✔
127	baseUtilLib.baseLib.info(`Adding hash of ${runvcpkglib.VCPKG_CONFIGURATION_JSON}: '${vcpkgConfJsonHash}'.`);	4✔
128	hash += `-vcpkgConfigurationJson=${vcpkgConfJsonHash}`;	4✔
129	}
130	cacheKeySegments.push(hash);	8✔
131	}
132
133	if (appendedCacheKey) {	9✔
134	cacheKeySegments.push(`appendedKey=${appendedCacheKey}`);	5✔
135	}
136
137	const keyset: baseutillib.KeySet = baseutillib.createKeySet(cacheKeySegments);	9✔
138	baseUtilLib.baseLib.debug(`computeCacheKeys()>>`);	9✔
139	return keyset;	9✔
140	}
141
142	public static async saveCache(baseLib: baselib.BaseLib, doNotCache: boolean, keys: baseutillib.KeySet,
143	hitCacheKey: string \| null, cachedPaths: string[]): Promise<void> {
144	baseLib.debug(`saveCache(doNotCache:${doNotCache},keys:${JSON.stringify(keys)},hitCacheKey:${hitCacheKey},cachedPaths:${cachedPaths})<<`)	4✔
145	try {	4✔
146	if (doNotCache) {	4!
UNCOV 147	baseLib.info(`Caching is disabled, saving cache is skipped.`);	×
148	} else {
149	if (hitCacheKey && Utils.isExactKeyMatch(keys.primary, hitCacheKey)) {	4✔
150	baseLib.info(`Saving cache is skipped, because cache hit occurred on the cache key '${keys.primary}'.`);	2✔
151	} else {
152	baseLib.info(`Saving a new cache entry, because primary key was missed or a fallback restore key was hit.`);	2✔
153	const pathsToCache: string[] = cachedPaths;	2✔
154	baseLib.info(`Caching paths: '${pathsToCache}'`);	2✔
155
156	try {	2✔
157	baseLib.info(`Saving cache with primary key '${keys.primary}' ...`);	2✔
158	await cache.saveCache(pathsToCache, keys.primary);	2✔
159	}
160	catch (error) {
161	if (error instanceof Error) {	1!
162	if (error.name === cache.ValidationError.name) {	1!
UNCOV 163	throw error;	×
164	} else if (error.name === cache.ReserveCacheError.name) {	1!
165	baseLib.info(error.message);	×
166	} else {
167	baseLib.warning(error.message);	1✔
168	}
169	}
170	}
171	}
172	}
173	} catch (err) {
UNCOV 174	baseLib.warning("vcpkg-utils.saveCache() failed!");	×
UNCOV 175	if (err instanceof Error) {	×
176	baseLib.warning(err.name);	×
177	baseLib.warning(err.message);	×
178	if (err?.stack) {	×
179	baseLib.warning(err.stack);	×
180	}
181	}
182	}
183
184	baseLib.debug(`saveCache()>>`)	4✔
185	}
186
187	public static addCachedPaths(baseLib: baselib.BaseLib, paths: string \| null): void {
188	baseLib.debug(`addCachedPaths(${paths})<<`)	11✔
189	if (paths) {	11✔
190	baseLib.debug(`Adding cached paths: '${paths}''`);	6✔
191	let s: string \| undefined = baseLib.getState(vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE);	6✔
192	s = `${s ?? ''};${paths}`;	6!
193	baseLib.setState(vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE, s);	6✔
194	baseLib.debug(`Set ${vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE}=${s}`);	6✔
195	}
196	baseLib.debug(`addCachedPaths()>>`)	11✔
197	}
198
199	public static getAllCachedPaths(baseLib: baselib.BaseLib, vcpkgRootDir: string): string[] {
200	baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<<`);	4✔
201	let pathsToCache: string[] = [];	4✔
202	// Hack-ish: ensure that VCPKG_DEFAULT_BINARY_CACHE is always added to the list of cached paths.
203	// When this functino is called by the action, the env var contains the binary cache path.
204	// When this function is called by the post action, the env var is not defined (but the path is in the "state").
205	const binCachePath: string \| undefined = process.env[vcpkgaction.VcpkgAction.VCPKG_DEFAULT_BINARY_CACHE];	4✔
206	if (binCachePath) {	4!
207	pathsToCache = pathsToCache.concat([binCachePath]);	4✔
208	}
209
210	const additionalCachedPaths: string \| undefined = baseLib.getState(vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE);	4✔
211	baseLib.debug(`getState(${vcpkgaction.VCPKG_ADDITIONAL_CACHED_PATHS_STATE}) -> '${additionalCachedPaths}'`);	4✔
212	if (additionalCachedPaths) {	4!
213	pathsToCache = pathsToCache.concat(additionalCachedPaths.split(';'));	4✔
214	}
215	pathsToCache = pathsToCache.concat(runvcpkglib.getOrdinaryCachedPaths(vcpkgRootDir));	4✔
216
217	// Remove empty entries.
218	pathsToCache = pathsToCache.map(s => s.trim()).filter(Boolean);	26✔
219
220	// Remove duplicates.
221	const ps = [...new Set(pathsToCache)];	4✔
222
223	baseLib.debug(`getAllCachedPaths(${vcpkgRootDir})<< -> '${JSON.stringify(ps)}'`);	4✔
224	return ps;	4✔
225	}
226	}

lukka / run-vcpkg / 3212722686

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous