chore: ran prettier

Author: cdaguerre

lib/adapters/apply-edit-adapter.ts

@@ -9,7 +9,7 @@ import {
   CreateFile,
   RenameFile,
   DeleteFile,
-  DocumentUri
+  DocumentUri,
 } from "../languageclient"
 import { TextBuffer, TextEditor } from "atom"
 import * as fs from "fs"
@@ -51,24 +51,26 @@ export default class ApplyEditAdapter {
     // Keep checkpoints from all successful buffer edits
     const checkpoints: Array<{ buffer: TextBuffer; checkpoint: number }> = []
 
-    const promises = (workspaceEdit.documentChanges || []).map(async (edit): Promise<void> => {
-      if (!TextDocumentEdit.is(edit)) {
-        return ApplyEditAdapter.handleResourceOperation(edit).catch((err) => {
-          throw Error(`Error during ${edit.kind} resource operation: ${err.message}`)
-        })
+    const promises = (workspaceEdit.documentChanges || []).map(
+      async (edit): Promise<void> => {
+        if (!TextDocumentEdit.is(edit)) {
+          return ApplyEditAdapter.handleResourceOperation(edit).catch((err) => {
+            throw Error(`Error during ${edit.kind} resource operation: ${err.message}`)
+          })
+        }
+        const path = Convert.uriToPath(edit.textDocument.uri)
+        const editor = (await atom.workspace.open(path, {
+          searchAllPanes: true,
+          // Open new editors in the background.
+          activatePane: false,
+          activateItem: false,
+        })) as TextEditor
+        const buffer = editor.getBuffer()
+        const edits = Convert.convertLsTextEdits(edit.edits)
+        const checkpoint = ApplyEditAdapter.applyEdits(buffer, edits)
+        checkpoints.push({ buffer, checkpoint })
       }
-      const path = Convert.uriToPath(edit.textDocument.uri)
-      const editor = (await atom.workspace.open(path, {
-        searchAllPanes: true,
-        // Open new editors in the background.
-        activatePane: false,
-        activateItem: false,
-      })) as TextEditor
-      const buffer = editor.getBuffer()
-      const edits = Convert.convertLsTextEdits(edit.edits)
-      const checkpoint = ApplyEditAdapter.applyEdits(buffer, edits)
-      checkpoints.push({ buffer, checkpoint })
-    })
+    )
 
     // Apply all edits or fail and revert everything
     const applied = await Promise.all(promises)
@@ -87,22 +89,20 @@ export default class ApplyEditAdapter {
     return { applied }
   }
 
-  private static async handleResourceOperation(edit: (CreateFile | RenameFile | DeleteFile)): Promise<void> {
+  private static async handleResourceOperation(edit: CreateFile | RenameFile | DeleteFile): Promise<void> {
     if (DeleteFile.is(edit)) {
       const path = Convert.uriToPath(edit.uri)
-      const exists = await fs.promises.stat(path).then(() => true).catch(() => false)
+      const stats: boolean | fs.Stats = await fs.promises.lstat(path).catch(() => false)
       const ignoreIfNotExists = edit.options?.ignoreIfNotExists
 
-      if (!exists) {
+      if (!stats) {
         if (ignoreIfNotExists) {
           return
         }
         throw Error(`Target doesn't exist.`)
       }
 
-      const isDirectory = fs.lstatSync(path).isDirectory()
-
-      if (isDirectory) {
+      if (stats.isDirectory()) {
         if (edit.options?.recursive) {
           return new Promise((resolve, reject) => {
             rimraf(path, { glob: false }, (err) => {
@@ -121,7 +121,10 @@ export default class ApplyEditAdapter {
     if (RenameFile.is(edit)) {
       const oldPath = Convert.uriToPath(edit.oldUri)
       const newPath = Convert.uriToPath(edit.newUri)
-      const exists = await fs.promises.stat(newPath).then(() => true).catch(() => false)
+      const exists = await fs.promises
+        .access(newPath)
+        .then(() => true)
+        .catch(() => false)
       const ignoreIfExists = edit.options?.ignoreIfExists
       const overwrite = edit.options?.overwrite
 
@@ -137,29 +140,32 @@ export default class ApplyEditAdapter {
     }
     if (CreateFile.is(edit)) {
       const path = Convert.uriToPath(edit.uri)
-      const exists = await fs.promises.stat(path).then(() => true).catch(() => false)
+      const exists = await fs.promises
+        .access(path)
+        .then(() => true)
+        .catch(() => false)
       const ignoreIfExists = edit.options?.ignoreIfExists
       const overwrite = edit.options?.overwrite
 
       if (exists && ignoreIfExists && !overwrite) {
         return
       }
 
-      return fs.promises.writeFile(path, '')
+      return fs.promises.writeFile(path, "")
     }
   }
 
   private static normalize(workspaceEdit: WorkspaceEdit): void {
     const documentChanges = workspaceEdit.documentChanges || []
 
-    if (!('documentChanges' in workspaceEdit) && ('changes' in workspaceEdit)) {
+    if (!("documentChanges" in workspaceEdit) && "changes" in workspaceEdit) {
       Object.keys(workspaceEdit.changes || []).forEach((uri: DocumentUri) => {
         documentChanges.push({
           textDocument: {
             version: null,
-            uri: uri
+            uri,
           },
-          edits: workspaceEdit.changes![uri]
+          edits: workspaceEdit.changes![uri],
         })
       })
     }

lib/auto-languageclient.ts

@@ -122,7 +122,7 @@ export default class AutoLanguageClient {
             documentChanges: true,
             normalizesLineEndings: false,
             changeAnnotationSupport: undefined,
-            resourceOperations: ["create", "rename", "delete"]
+            resourceOperations: ["create", "rename", "delete"],
           },
           workspaceFolders: false,
           didChangeConfiguration: {

test/adapters/apply-edit-adapter.test.ts

@@ -11,7 +11,7 @@ const TEST_PATH1 = normalizeDriveLetterName(path.join(__dirname, "test.txt"))
 const TEST_PATH2 = normalizeDriveLetterName(path.join(__dirname, "test2.txt"))
 const TEST_PATH3 = normalizeDriveLetterName(path.join(__dirname, "test3.txt"))
 const TEST_PATH4 = normalizeDriveLetterName(path.join(__dirname, "test4.txt"))
-const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'atom-languageclient-tests'))
+const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "atom-languageclient-tests"))
 
 function normalizeDriveLetterName(filePath: string): string {
   if (process.platform === "win32") {
@@ -194,105 +194,105 @@ describe("ApplyEditAdapter", () => {
       const directory = fs.mkdtempSync(tempDir)
       const oldUri = path.join(directory, "test.txt")
       const newUri = path.join(directory, "test-renamed.txt")
-      fs.writeFileSync(oldUri, 'abcd')
+      fs.writeFileSync(oldUri, "abcd")
 
       const result = await ApplyEditAdapter.onApplyEdit({
         edit: {
           documentChanges: [
             {
               kind: "rename",
-              oldUri: oldUri,
-              newUri: newUri,
-            }
-          ]
+              oldUri,
+              newUri,
+            },
+          ],
         },
       })
 
       expect(result.applied).to.equal(true)
       expect(fs.existsSync(newUri)).to.equal(true)
-      expect(fs.readFileSync(newUri).toString()).to.equal('abcd')
+      expect(fs.readFileSync(newUri).toString()).to.equal("abcd")
       expect(fs.existsSync(oldUri)).to.equal(false)
     })
 
     it("handles rename operation with ignoreIfExists option", async () => {
       const directory = fs.mkdtempSync(tempDir)
       const oldUri = path.join(directory, "test.txt")
       const newUri = path.join(directory, "test-renamed.txt")
-      fs.writeFileSync(oldUri, 'abcd')
-      fs.writeFileSync(newUri, 'efgh')
+      fs.writeFileSync(oldUri, "abcd")
+      fs.writeFileSync(newUri, "efgh")
 
       const result = await ApplyEditAdapter.onApplyEdit({
         edit: {
           documentChanges: [
             {
               kind: "rename",
-              oldUri: oldUri,
-              newUri: newUri,
+              oldUri,
+              newUri,
               options: {
-                ignoreIfExists: true
-              }
-            }
-          ]
+                ignoreIfExists: true,
+              },
+            },
+          ],
         },
       })
 
       expect(result.applied).to.equal(true)
       expect(fs.existsSync(oldUri)).to.equal(true)
-      expect(fs.readFileSync(newUri).toString()).to.equal('efgh')
+      expect(fs.readFileSync(newUri).toString()).to.equal("efgh")
     })
 
     it("handles rename operation with overwrite option", async () => {
       const directory = fs.mkdtempSync(tempDir)
       const oldUri = path.join(directory, "test.txt")
       const newUri = path.join(directory, "test-renamed.txt")
-      fs.writeFileSync(oldUri, 'abcd')
-      fs.writeFileSync(newUri, 'efgh')
+      fs.writeFileSync(oldUri, "abcd")
+      fs.writeFileSync(newUri, "efgh")
 
       const result = await ApplyEditAdapter.onApplyEdit({
         edit: {
           documentChanges: [
             {
               kind: "rename",
-              oldUri: oldUri,
-              newUri: newUri,
+              oldUri,
+              newUri,
               options: {
                 overwrite: true,
-                ignoreIfExists: true // Overwrite wins over ignoreIfExists
-              }
-            }
-          ]
+                ignoreIfExists: true, // Overwrite wins over ignoreIfExists
+              },
+            },
+          ],
         },
       })
 
       expect(result.applied).to.equal(true)
       expect(fs.existsSync(oldUri)).to.equal(false)
-      expect(fs.readFileSync(newUri).toString()).to.equal('abcd')
+      expect(fs.readFileSync(newUri).toString()).to.equal("abcd")
     })
 
     it("throws an error on rename operation if target exists", async () => {
       const directory = fs.mkdtempSync(tempDir)
       const oldUri = path.join(directory, "test.txt")
       const newUri = path.join(directory, "test-renamed.txt")
-      fs.writeFileSync(oldUri, 'abcd')
-      fs.writeFileSync(newUri, 'efgh')
+      fs.writeFileSync(oldUri, "abcd")
+      fs.writeFileSync(newUri, "efgh")
 
       const result = await ApplyEditAdapter.onApplyEdit({
         edit: {
           documentChanges: [
             {
               kind: "rename",
-              oldUri: oldUri,
-              newUri: newUri,
-            }
-          ]
+              oldUri,
+              newUri,
+            },
+          ],
         },
       })
 
       expect(result.applied).to.equal(false)
       expect(fs.existsSync(oldUri)).to.equal(true)
-      expect(fs.readFileSync(oldUri).toString()).to.equal('abcd')
+      expect(fs.readFileSync(oldUri).toString()).to.equal("abcd")
       expect(fs.existsSync(newUri)).to.equal(true)
-      expect(fs.readFileSync(newUri).toString()).to.equal('efgh')
+      expect(fs.readFileSync(newUri).toString()).to.equal("efgh")
 
       expect(
         (atom as any).notifications.addError.calledWith("workspace/applyEdits failed", {
@@ -305,16 +305,16 @@ describe("ApplyEditAdapter", () => {
     it("handles delete resource operations on files", async () => {
       const directory = fs.mkdtempSync(tempDir)
       const uri = path.join(directory, "test.txt")
-      fs.writeFileSync(uri, 'abcd')
+      fs.writeFileSync(uri, "abcd")
 
       const result = await ApplyEditAdapter.onApplyEdit({
         edit: {
           documentChanges: [
             {
               kind: "delete",
-              uri: uri
-            }
-          ]
+              uri,
+            },
+          ],
         },
       })
 
@@ -324,10 +324,10 @@ describe("ApplyEditAdapter", () => {
 
     it("handles delete resource operations on directories", async () => {
       const directory = fs.mkdtempSync(tempDir)
-      const file1 = path.join(directory, '1.txt')
-      const file2 = path.join(directory, '2.txt')
-      fs.writeFileSync(file1, '1')
-      fs.writeFileSync(file2, '2')
+      const file1 = path.join(directory, "1.txt")
+      const file2 = path.join(directory, "2.txt")
+      fs.writeFileSync(file1, "1")
+      fs.writeFileSync(file2, "2")
 
       const result = await ApplyEditAdapter.onApplyEdit({
         edit: {
@@ -336,10 +336,10 @@ describe("ApplyEditAdapter", () => {
               kind: "delete",
               uri: directory,
               options: {
-                recursive: true
-              }
-            }
-          ]
+                recursive: true,
+              },
+            },
+          ],
         },
       })
 
@@ -351,10 +351,10 @@ describe("ApplyEditAdapter", () => {
 
     it("throws an error when deleting a non-empty directory without recursive option", async () => {
       const directory = fs.mkdtempSync(tempDir)
-      const file1 = path.join(directory, '1.txt')
-      const file2 = path.join(directory, '2.txt')
-      fs.writeFileSync(file1, '1')
-      fs.writeFileSync(file2, '2')
+      const file1 = path.join(directory, "1.txt")
+      const file2 = path.join(directory, "2.txt")
+      fs.writeFileSync(file1, "1")
+      fs.writeFileSync(file2, "2")
 
       const result = await ApplyEditAdapter.onApplyEdit({
         edit: {
@@ -363,10 +363,10 @@ describe("ApplyEditAdapter", () => {
               kind: "delete",
               uri: directory,
               options: {
-                recursive: false
-              }
-            }
-          ]
+                recursive: false,
+              },
+            },
+          ],
         },
       })
 
@@ -379,16 +379,15 @@ describe("ApplyEditAdapter", () => {
       expect(errorCalls[0].args[1].detail).to.match(/Error during delete resource operation: (.*)/)
     })
 
-
     it("throws an error on delete operation if target doesnt exist", async () => {
       const result = await ApplyEditAdapter.onApplyEdit({
         edit: {
           documentChanges: [
             {
               kind: "delete",
               uri: path.join(tempDir, "unexisting.txt"),
-            }
-          ]
+            },
+          ],
         },
       })
       //
@@ -410,9 +409,9 @@ describe("ApplyEditAdapter", () => {
           documentChanges: [
             {
               kind: "create",
-              uri: uri
-            }
-          ]
+              uri,
+            },
+          ],
         },
       })