rename: exists methods

fileExists -> existsFile
directoryExists -> existsDir

Signed-off-by: nkomonen <[email protected]>

Author: nkomonen-amazon

src/amazonqFeatureDev/util/files.ts

@@ -133,5 +133,5 @@ export async function prepareRepoData(
 
 export async function getSourceCodePath(workspaceRoot: string, projectRoot: string) {
     const srcRoot = path.join(workspaceRoot, projectRoot)
-    return (await fsCommon.directoryExists(srcRoot)) ? srcRoot : workspaceRoot
+    return (await fsCommon.existsDir(srcRoot)) ? srcRoot : workspaceRoot
 }

src/codewhisperer/vue/backend.ts

@@ -39,7 +39,7 @@ export class CodeWhispererWebview extends VueWebview {
         const fileContent = name[1]
 
         const localFilePath = this.getLocalFilePath(fileName)
-        if ((await fsCommon.fileExists(localFilePath)) && this.isFileSaved) {
+        if ((await fsCommon.existsFile(localFilePath)) && this.isFileSaved) {
             const fileUri = vscode.Uri.file(localFilePath)
             await vscode.workspace.openTextDocument(fileUri).then(async doc => {
                 await vscode.window.showTextDocument(doc, vscode.ViewColumn.Active).then(editor => {

src/shared/filesystemUtilities.ts

@@ -53,7 +53,7 @@ export async function getDirSize(
 
 async function downloadsDir(): Promise<string> {
     const downloadPath = path.join(os.homedir(), 'Downloads')
-    if (await fsCommon.directoryExists(downloadPath)) {
+    if (await fsCommon.existsDir(downloadPath)) {
         return downloadPath
     } else {
         return os.tmpdir()
@@ -204,14 +204,14 @@ export async function getNonexistentFilename(
     if (!name) {
         throw new Error(`name is empty`)
     }
-    if (!(await fsCommon.directoryExists(dir))) {
+    if (!(await fsCommon.existsDir(dir))) {
         throw new Error(`directory does not exist: ${dir}`)
     }
     for (let i = 0; true; i++) {
         const filename =
             i === 0 ? `${name}${suffix}` : `${name}-${i < max ? i : crypto.randomBytes(4).toString('hex')}${suffix}`
         const fullpath = path.join(dir, filename)
-        if (!(await fsCommon.fileExists(fullpath)) || i >= max + 99) {
+        if (!(await fsCommon.existsFile(fullpath)) || i >= max + 99) {
             return filename
         }
     }
@@ -278,7 +278,7 @@ export async function cloud9Findfile(dir: string, fileName: string): Promise<vsc
         if (filePath === path.join(dir, fileName)) {
             return [vscode.Uri.file(filePath)]
         }
-        if (await fsCommon.directoryExists(filePath)) {
+        if (await fsCommon.existsDir(filePath)) {
             subDirs.push(vscode.Uri.file(filePath))
         }
     }
@@ -306,7 +306,7 @@ export async function getDefaultDownloadPath(): Promise<string> {
 
 export async function setDefaultDownloadPath(downloadPath: string) {
     try {
-        if (await fsCommon.directoryExists(downloadPath)) {
+        if (await fsCommon.existsDir(downloadPath)) {
             GlobalState.instance.tryUpdate('aws.downloadPath', downloadPath)
         } else {
             GlobalState.instance.tryUpdate('aws.downloadPath', path.dirname(downloadPath))

src/shared/logger/activation.ts

@@ -178,7 +178,7 @@ async function createLogWatcher(logFile: vscode.Uri): Promise<vscode.Disposable>
         return { dispose: () => {} }
     }
 
-    const exists = await waitUntil(() => fsCommon.fileExists(logFile), { interval: 1000, timeout: 60000 })
+    const exists = await waitUntil(() => fsCommon.existsFile(logFile), { interval: 1000, timeout: 60000 })
 
     if (!exists) {
         getLogger().warn(`Log file ${logFile.path} does not exist!`)
@@ -195,7 +195,7 @@ async function createLogWatcher(logFile: vscode.Uri): Promise<vscode.Disposable>
             return
         }
         checking = true
-        if (!(await fsCommon.fileExists(logFile))) {
+        if (!(await fsCommon.existsFile(logFile))) {
             await vscode.window.showWarningMessage(
                 localize('AWS.log.logFileMove', 'The log file for this session has been moved or deleted.')
             )

src/shared/telemetry/telemetryService.ts

@@ -167,7 +167,7 @@ export class DefaultTelemetryService {
      * VSCode provides the URI of the folder, but it is not guaranteed to exist.
      */
     private static async ensureGlobalStorageExists(context: ExtensionContext): Promise<void> {
-        if (!fsCommon.fileExists(context.globalStorageUri)) {
+        if (!fsCommon.existsFile(context.globalStorageUri)) {
             await fsCommon.mkdir(context.globalStorageUri)
         }
     }
@@ -289,7 +289,7 @@ export class DefaultTelemetryService {
 
     private static async readEventsFromCache(cachePath: string): Promise<MetricDatum[]> {
         try {
-            if ((await fsCommon.fileExists(cachePath)) === false) {
+            if ((await fsCommon.existsFile(cachePath)) === false) {
                 getLogger().info(`telemetry cache not found: '${cachePath}'`)
 
                 return []

src/srcShared/fs.ts

@@ -69,7 +69,7 @@ export class FileSystemCommon {
     async appendFile(path: Uri | string, content: Uint8Array | string): Promise<void> {
         path = FileSystemCommon.getUri(path)
 
-        const currentContent: Uint8Array = (await this.fileExists(path)) ? await this.readFile(path) : new Uint8Array(0)
+        const currentContent: Uint8Array = (await this.existsFile(path)) ? await this.readFile(path) : new Uint8Array(0)
         const currentLength = currentContent.length
 
         const newContent = FileSystemCommon.asArray(content)
@@ -93,11 +93,11 @@ export class FileSystemCommon {
         }
     }
 
-    async fileExists(path: Uri | string): Promise<boolean> {
+    async existsFile(path: Uri | string): Promise<boolean> {
         return this.exists(path, vscode.FileType.File)
     }
 
-    async directoryExists(path: Uri | string): Promise<boolean> {
+    async existsDir(path: Uri | string): Promise<boolean> {
         return this.exists(path, vscode.FileType.Directory)
     }
 

src/test/credentials/ui/vue/show.test.ts

@@ -174,8 +174,8 @@ describe('Add Connection webview', function () {
         const projectRoot = Uri.joinPath(Uri.file(getProjectDir()), '..', '..')
         const marketplaceImagesRoot = Uri.joinPath(projectRoot, 'docs/marketplace/vscode')
 
-        assert(await fsCommon.fileExists(Uri.joinPath(marketplaceImagesRoot, 'CC_dev_env.gif')))
-        assert(await fsCommon.fileExists(Uri.joinPath(marketplaceImagesRoot, 'awsExplorer.gif')))
-        assert(await fsCommon.fileExists(Uri.joinPath(marketplaceImagesRoot, 'codewhispererChat.gif')))
+        assert(await fsCommon.existsFile(Uri.joinPath(marketplaceImagesRoot, 'CC_dev_env.gif')))
+        assert(await fsCommon.existsFile(Uri.joinPath(marketplaceImagesRoot, 'awsExplorer.gif')))
+        assert(await fsCommon.existsFile(Uri.joinPath(marketplaceImagesRoot, 'codewhispererChat.gif')))
     })
 })

src/test/srcShared/fs.test.ts

@@ -117,34 +117,34 @@ describe('FileSystem', function () {
         })
     })
 
-    describe('fileExists()', function () {
+    describe('existsFile()', function () {
         it('returns true for an existing file', async function () {
             const filePath = await makeFile('test.txt')
-            const existantFile = await fsCommon.fileExists(filePath)
+            const existantFile = await fsCommon.existsFile(filePath)
             assert.strictEqual(existantFile, true)
         })
 
         it('returns false for a non-existant file', async function () {
-            const nonExistantFile = await fsCommon.fileExists(createTestPath('thisDoesNotExist.txt'))
+            const nonExistantFile = await fsCommon.existsFile(createTestPath('thisDoesNotExist.txt'))
             assert.strictEqual(nonExistantFile, false)
         })
 
         it('returns false when directory with same name exists', async function () {
             const directoryPath = await makeFolder('thisIsDirectory')
-            const existantFile = await fsCommon.fileExists(directoryPath)
+            const existantFile = await fsCommon.existsFile(directoryPath)
             assert.strictEqual(existantFile, false)
         })
     })
 
-    describe('directoryExists()', function () {
+    describe('existsDir()', function () {
         it('returns true for an existing directory', async function () {
             const dirPath = await makeFolder('myDir')
-            const existantDirectory = await fsCommon.directoryExists(dirPath)
+            const existantDirectory = await fsCommon.existsDir(dirPath)
             assert.strictEqual(existantDirectory, true)
         })
 
         it('returns false for a non-existant directory', async function () {
-            const nonExistantDirectory = await fsCommon.directoryExists(createTestPath('thisDirDoesNotExist'))
+            const nonExistantDirectory = await fsCommon.existsDir(createTestPath('thisDirDoesNotExist'))
             assert.strictEqual(nonExistantDirectory, false)
         })
     })